This is Codefree's own story: before we built Klientele, our software and IT services firm ran its client work on four tools that didn't talk to each other. Nobody chose that stack. Each tool arrived to fix one pain — tickets needed a home, hours were scattered across notebooks, the accountant wanted proper invoices, and someone built a spreadsheet late one night to stop retainer hours slipping away. Eventually all four were running side by side, and the operation was held together by people's memory and a Monday-morning meeting nobody enjoyed.
What was the four-tool stack Codefree ran on?
Direct answer: Codefree's stack was a project tool (Jira), a time tracker (Toggl), an accounting and invoicing tool (QuickBooks) and a shared spreadsheet for retainers. Nobody chose it as a whole; it built up one problem at a time until it was too entangled to unpick.
By late 2024, Codefree was running on this:
- Jira for tickets and sprints. Good at tickets. Nobody outside engineering wanted to open it.
- Toggl for time. A good timer with no idea what the work was for — every entry was free text that someone had to interpret later.
- QuickBooks for invoicing. Right on tax, right on totals, slow to use because the source numbers lived somewhere else.
- A shared spreadsheet for retainers, named something like `Retainers-Master-DO-NOT-EDIT`. Everyone edited it.
Each tool did its own job well. That was the trap. Nothing was obviously broken; it just took more and more manual effort to make four tools behave like one system.
“Nobody chose the four-tool stack. It was built one crisis at a time, and because every tool "worked", nobody had a reason to take it apart.”
Where does the four-tool stack leak money?
Direct answer: It leaked at every seam where information had to move between tools — vague time entries that had to be matched to a client by hand, retainer hours added up in a spreadsheet the night before invoicing, invoices retyped from numbers that already existed elsewhere, and payments tracked in the same spreadsheet.
The cost wasn't in the tools. It was at the seams, where a piece of information had to move from one tool to the next and got dropped, delayed or entered twice.
Seam 1 — Work to time entry
An engineer starts a timer, remembers halfway through which ticket it belongs to, and types a description. At the end of the week someone exports the time and matches each entry to a client. Entries like "bug fix" or "call" meant chasing the engineer to ask which client it was for. Hours fell between the tools.
Seam 2 — Time to retainer
A client has a monthly retainer. Is it on track? Nobody knows until someone opens the spreadsheet, filters the time export by client, adds it up and compares it to the allowance. Some weeks that happened the night before invoicing. Some weeks it didn't happen, and we found out mid-month that a retainer was already nearly used up — too late to have the scope conversation.
Seam 3 — Retainer to invoice
At month-end someone added up each client's hours, opened the accounting tool, created an invoice and typed in the retainer fee and any overage. If unused hours were meant to roll over, someone had to remember. If the client went over, someone had to remember the overage line and the right rate. Month-end was a hunt.
Seam 4 — Invoice to cash
Once an invoice went out, payment status lived in the same spreadsheet. When money arrived, someone marked it paid in two places. When it didn't, the spreadsheet was the only place that showed it. Overdue invoices got chased when someone noticed, which was not the same as when they were overdue.
Why did Codefree need a Monday reconciliation meeting?
Direct answer: The Monday meeting existed because the four tools didn't talk to each other. Someone exported each one, someone matched them up, and the people who ran delivery and money walked through the gaps on Monday morning — catching problems only after they had already happened.
Every Monday morning the people responsible for delivery and money sat down to answer one question: "How are we actually doing?" Which retainers were running over, which invoices were late, which projects were slipping, which client was unhappy.
The meeting was how we compensated for tools that didn't share anything. It felt productive because it always found something — but everything it found had already happened. We weren't running the operation. We were auditing it.
“If your business needs a Monday reconciliation meeting, your operation isn't being run — it's being audited.”
What finally broke the four-tool stack for Codefree?
Direct answer: No single number broke it. It was the steady realisation that we couldn't answer basic questions — how much of this retainer is left, what does this client owe, what is everyone working on this week — without a meeting and a set of exports.
We were paying four subscriptions to know less than we needed to. Retainer hours were slipping through, invoices were going out later than the work justified, and the founder's week was going into reconciliation instead of clients. We looked for a single tool that covered the whole path from a client's request to a paid invoice, didn't find one we wanted to run our business on, and started building Klientele in late 2024.
What changed inside Codefree after replacing the four tools with Klientele?
Direct answer: Requests, time, retainers and invoices moved into one place. Time is logged against the request it belongs to, retainers draw down from that time, invoices are drafted from it, and the Monday meeting became a look at the dashboard and the Monday summary email.
We moved one workflow at a time — requests first, then time, then retainers, then invoices — and retired each old tool once its replacement had carried real work. Codefree ran its own client work on Klientele for more than a year before we opened it to other service businesses in 2026.
- One numbered request queue. Client requests from the portal, email and the website widget land in the same list.
- Time on the work it belongs to. The timer runs on the request, so nobody has to guess later which client a vague entry was for.
- Retainers that know their own balance. Logged time draws the retainer down; unused hours roll over up to a cap; overage lands on the next invoice.
- Invoices drafted from what was logged. Built from time, retainers, fixed fees or milestones, and locked once sent.
- Clients see it too. In the portal, clients see their open work, what they owe and their retainer balance.
The Monday meeting is the change that lands hardest when we tell this story. Every service business has its own version of it, and most of it can be replaced by information that stays current all week.
What is the four-tool stack really costing your service business?
Direct answer: The cost rarely shows up as a line item. It hides in hours that never get billed, invoices that go out later than they should, staff time spent copying numbers between tools, and the owner's attention spent reconciling instead of running the business.
- Retainer leak — hours used but never billed, because adding them up is a manual job that doesn't always happen.
- Late invoices — every day an invoice waits for someone to assemble it is a day later the money arrives.
- Copying between tools — time spent retyping numbers that already exist somewhere else, instead of on clients.
- The owner's attention — the most expensive cost. Every hour spent reconciling is an hour not spent on clients or growth.
None of these appear on your accounts. All of them are real.
Codefree didn't set out to build a software product. We built Klientele because our own four-tool stack kept leaking hours and attention, and nothing we found covered the whole path from request to paid invoice. If you're on the same kind of stack, you're not behind — it's where most service businesses end up by default. Invoicing and retainers are on the Team and Agency plans. Start a 14-day trial and see which part of your week it replaces first.
Last updated October 4, 2026