This is Codefree's own story: we are a software and IT services firm, and we build Klientele. In late 2024 we started building it as an internal project, because we needed better tooling to run our own client work. We ran that work on it for more than a year before opening it to outside service businesses in 2026, when DevFlow — its internal name — became Klientele and trials opened. **That gap between "we use it" and "we sell it" was deliberate.** This is why, and what happened during it that made the product better than it would have been if we had shipped early.
Why did Codefree skip the MVP for post-sales software?
Direct answer: For three reasons: software that runs billing and client work is unforgiving of missing pieces (a wrong invoice is not a fix-it-later bug), the honest test loop is monthly rather than daily (retainer rollover only proves itself when the month turns), and we were a demanding customer — every gap immediately became a real problem in our own client work.
Most startup advice says: build the smallest thing, put it in front of real users, iterate on their feedback. That advice is right for most software. It was wrong for this one.
Reason 1 — this kind of software is unforgiving of missing pieces. If a task list is missing a feature, people work around it. If billing is missing a feature, invoices go out wrong and clients get upset. If retainer tracking is missing a feature, hours leak. There is no quiet recovery from an invoice that went out with the wrong tax line.
Reason 2 — the honest test loop is monthly. Does retainer rollover behave correctly? You find out when the month turns. Do deadline reminders fire at the right moment? Only when a real deadline arrives. Fast iteration depends on daily feedback; most of the real feedback in this area arrives weeks later.
Reason 3 — we were a demanding customer. Codefree already had clients to serve. Every gap in the product became a gap in our own operation. If it produced a wrong invoice, we risked a real client's trust, not an early user's patience. That pressure is what shaped the product.
“Ship-fast-and-learn works when the cost of a bug is frustration. It doesn't work when the cost of a bug is a wrong invoice. Some software deserves to ship late.”
In what order did Codefree build Klientele?
Direct answer: In five layers, each carrying our own client work before the next began: intake (every client request in one queue), execution (workflow, weekly capacity and the estimation calculator), delivery (time, retainers and invoices), visibility (dashboards, the daily digest and the Monday summary) and configuration (industry templates).
Layer 1: Intake
Every request to Codefree went into one numbered queue. Client emails were forwarded to a workspace address that turned them into requests, a widget on our own site captured bug reports with screenshots, and the team worked in the app directly. The signal that it worked: nobody opened the old ticket tool for anything new.
Layer 2: Execution
Workflow steps, weekly capacity plans and the estimation calculator. Each week was planned in Klientele, and every estimate went through the multipliers before anyone committed to a date.
Layer 3: Delivery
The timer, retainers, invoices and invoice PDFs. This was the hardest and most consequential layer, and it replaced our time tracker, our accounting tool's invoicing and our retainer spreadsheet. The signal that it worked was unglamorous: an invoice built entirely in Klientele went to a client, was correct, and was paid. That is a low bar until you have sent a wrong one.
Layer 4: Visibility
Dashboards shaped for each seat, the daily digest and the Monday summary, and live updates in the app. The signal: we stopped holding the Monday reconciliation meeting, and nobody missed it.
Layer 5: Configuration
Industry templates that set terminology, workflow steps, required fields and roles for each kind of practice. There are now eight: legal, healthcare, accounting, architecture, consulting, marketing agency, technology / IT services and vet clinics.
What almost killed Klientele — the pressure to ship early?
Direct answer: Steady pressure to open early — from partners, from people who wanted to hear about the tooling, and from our own impatience. Each request made sense on its own. Taken together they would have meant selling a request tracker that called itself a post-sales platform before billing had carried our own month-ends.
The hardest part of building a product for a long time before selling it is resisting the pull to sell it sooner. Early on, the billing layer didn't exist; opening then would have meant shipping half a product. Later, the product looked finished long before it had proved itself through enough real month-ends. We held until it had.
What did more than a year of internal use change about Klientele?
Direct answer: Four changes stand out: retainer rollover was rewritten after it mishandled a retainer that was being edited as the month turned, overdue reminders were folded into a digest after one bad day flooded our own inboxes, the estimation buffer became U-shaped after our own data showed a flat buffer missing at both ends, and we began separating internal information from what clients see after our own clients asked awkward questions.
Retainer rollover. Our first version mishandled rollover on a retainer whose settings were being changed as the month turned. We found it on our own books and rewrote it so a rerun can't apply rollover twice. An outside customer would have been billed wrong before we noticed.
Overdue reminders. The first version sent an email per overdue item. On a day when several deadlines slipped together, our own team was buried in notifications. We folded them into a digest per person listing all their overdue work. Shipped as it was, it would have taught customers to filter our emails.
The estimation buffer. We started with one flat buffer. Our own estimate-versus-actual records showed it was short on the smallest and largest jobs, so it became a bracket that is higher at both ends.
What clients see. The first portal showed clients far too much of what the team saw, including internal notes and estimates. Our own clients asked uncomfortable questions. That started the split between internal and client-visible comments — an area we are still tightening.
“Every one of these fixes cost no customer trust, because we were the customer. Learned on outside users, the same lessons would have been far more expensive.”
How did Codefree decide Klientele was ready to sell externally?
Direct answer: Not by a launch date. The bar was that our own operation had to run on Klientele alone — requests, time, retainers and invoices — through repeated month-ends without falling back to the old tools or fixing invoices by hand.
Concretely, that meant: no request living outside the queue, no time tracked anywhere else, no retainer reconciled in a spreadsheet, and month-end invoicing done from what was logged. Once that had held for a sustained stretch, we spent the remaining time on documentation, the website and the industry templates, and opened Klientele to outside service businesses in 2026.
What did Codefree learn from internal use that we did not expect?
Direct answer: Three things: (1) the industry template matters more than the platform underneath — a law firm's first day is defined by whether the form says "Matter" or "Ticket", (2) the internal team's daily experience decides whether the product is kept, and (3) nobody wants a blank workflow builder; people want sensible defaults with room to adjust.
The template matters more than the platform. We expected the retainer maths, the audit log and the capacity planning to be what people noticed. They matter. But the templates were the difference between "capable software" and "software that feels built for us". A law firm's first day depends on whether it says "Matter" or "Ticket".
The internal team decides. Client-facing features — the portal, shareable invoice links — were used less often than we predicted. Internal features — the activity log, the dashboards, the capacity planner — were asked for constantly. Post-sales software is kept or dropped on the team's daily experience, then judged by the client's occasional visit.
Sensible defaults beat a blank canvas. We built a flexible custom-field system. Our own team barely used it; they wanted the template to be right on day one and to customise only the exceptions. That changed how we design templates: opinionated defaults that cover most of the work, with room to adjust the rest.
What changed when Klientele opened to external customers?
Direct answer: The product didn't change overnight when Klientele opened in 2026; it had already carried our own work for more than a year. What changed was how we hear feedback: internal feedback is instant, while outside customers are polite and quiet, so we have to ask for it directly.
Inside Codefree, someone tells me within minutes when something is confusing. Outside customers rarely do. They won't say the notifications are too many; they'll stop reading them. They won't say the wording feels wrong; they'll quietly stop logging in. So we ask — directly and often — and we read what people do, not just what they say.
Codefree spent more than a year running its own client work on Klientele before selling it, on the belief that this kind of software should be built by people who have to live with it. Klientele is now open to outside service businesses, with templates for eight industries: legal, healthcare, accounting, architecture, consulting, marketing agency, technology / IT services and vet clinics. The version you sign up for ran our own business first. On the Team and Agency plans, the retainer and invoice maths you see on day one is the same maths we run our own month-ends on.
Last updated October 4, 2026