How We Fired Our $7k/Year SaaS: Building a Custom Time Tracker in Just 80 Hours

The story of how we became our own client and saved thousands with an Agentic Engineering build that took only 80 hours.

Contact us

Key Takeaways

Hidden SaaS costs often show up as hours of manual spreadsheet work
Your team's daily workarounds are the perfect, field-tested requirements for custom software
Our AI Agentic Development workflow turned a 300 - 500h development estimate into a 80h build
AI Agentic Engineering drastically lowers costs, making previously dropped ideas and projects viable again

80h

to build, against a 300 to 500 h estimate

20h

of manual work gone, every month

105

people use it every day

months to pay for itself

$7k

a year subscription gone

$49k

saved in subscription and manual work saved over 5 years

Our Payroll Admin opens Clockify in report view and filters it down to one person. She checks their logged time against the export they sent her, types the result into a spreadsheet, and moves on to the next one. There are about 105 of them. Once she’s done with payroll, she repeats the process from a project perspective for billing purposes.

The exports were not her job. Everyone pulled their own, partly for the archive and partly because there was no room left on her plate for 105 more of anything.

20 hours a month and 240 hours annually, and that is only her share. She does it carefully, as based on these numbers employees get paid and clients invoiced, there’s no room for error.

We were paying $6.917 per year for the software that produced that report, without the possibility of exporting in a format that would fit our needs.

The real cost never appeared on the invoice

The subscription was the part we could see. 105 seats on the Standard plan, almost $7k billed annually, growing every time we hired someone.

We knew that roughly 20 hours a month were spent copying and reformatting data for payroll and client invoices. But measuring that one bottleneck opened a bigger question: what else are we working around?

What convinced us into building our own was not the invoice. It was the small stuff. Every day the software did one thing and we needed another, so somebody closed the gap by hand:

Invoicing & Payroll: Generating payroll and client invoices required copying, and pasting data into the spreadsheet.
Leave Balances: Answering a simple time-off request meant opening a separate file, calculating the remaining days, and following up.
Retainer Tracking: Without real-time visibility, team members had to confirm current usage with the Account Manager.
Data Visibility: We were frequently stuck choosing between showing people numbers they shouldn't see, or hiding data they actually needed to work efficiently.

We were paying for the subscription and still finishing the job ourselves.

None of this is a complaint about Clockify. It was built for everyone, and everyone is not a process.

300 hours we didn't have,
not 300 hours we couldn't afford

We had looked at building our own. In 2023 our developers estimated it at 300 to 500 hours.

The money was the smaller problem. We are a software agency. Senior engineering time is not a line in a budget, it is the service we provide and ours was booked. Three hundred hours meant 8 to 12 weeks of Senior Engineer’s time and client needs always came first. Building our own time tracker meant asking one of our dear clients to wait while we sorted out our own paperwork. Nobody was going to approve that, and nobody should have

So we kept paying, which was the sensible call at the time. Twenty hours of manual work a month is cheaper than four hundred hours of engineering time you do not have.

It is also why the smaller problems stayed. Each one on its own was too small to win an argument against client work. Together they were worth fixing. Since we never had the time to dig deeper, we didn’t know how big of an impact our tool’s shortcomings had on the entire organization.

Replacing what Clockify did for us came back at 50 hours. The payroll reporting and leave management we actually wanted added another 30. At 80 hours it stopped being a trade. Nothing had to be rescheduled and no client had to wait. That is what got the tool built, more than the savings ever would have.

Want to estimate your project?

Ours was estimated at 300 to 500 hours in 2023 and now it shipped in 80. If you priced something once and dropped it, the number is worth checking again.

Let’s talk

Put your own numbers in

Which tool?

Number of seats

Cost per seat, per month

Hours a month lost to manual workarounds

Assumptions80–240 hours at $90.00/hour

Your blended hourly rate

Implied by our own $400/month for ~20 hours. Change it to yours.

Hosting for the replacement

AWS, at the scale of our own build. Yours may differ - but it is never zero.

Build effort, 2 weeks: 80 h
Build effort, 6 weeks: 240 h
Our rate: $90

Time and materials, our standard client rate.

Indicative only, and a range rather than a quote - based on a 2 to 6 week commercial engagement at our standard rate. We size it properly, and for free, before anyone commits to anything.

Licence, a year

$12,000.00

What the tool costs you in subscription alone.

40 seats × $25.00/month × 12.

Workaround, a year

$4,800.00

The hours nobody has ever managed to automate, costed.

20 h/month × $20.00/hour × 12.

Net saving, a year

$16,440.00

After the replacement is live, and after its hosting.

Licence + workaround − $30.00/month hosting, × 12.

Pays for itself in

5.3–15.8 months

A range, because the build is a range. Two weeks to six.

80–240 h × $90.00/hour ÷ the net monthly saving.

Three years of staying

$36,000

Against $8,280–$22,680 to build it and host it for the same three years.

36 months of licence spend against build plus hosting. Licence only - the workaround hours above are not counted here.

Same team, same job, a different number

Nothing about the problem had changed. What changed was how much of our capacity a build this size uses up.

Once the AI Agentic Development Workflow was running on client projects, re-estimating the tracker was just arithmetic.

It runs in four parts - eight steps.

It starts the way any of our projects starts.

A written spec.
Boilerplate and scaffolding from our own tuned setup, so the project begins on the practices we would have applied by hand anyway.
Then an orchestrator agent breaks the work into tasks and assigns them.

Then a loop.

A coding agent implements the task it was given.
A simplifying agent goes over that implementation and reduces it, usually by reusing logic that already exists instead of letting a copy of it accumulate.
A third agent then reviews what the two of them produced, flags what it finds, and hands it back to the orchestrator, which assigns it out again. That runs until every P0 and P1 is gone.

Then a bigger loop.

Only once the first one is clean does an independent Codex-based reviewer read the whole diff rather than the individual task. What it finds goes back to the orchestrator, and the first loop starts over.

Then a person.

Lead AI Engineer approves every pull request and commits to production.

Three of those steps matter more than the speed.

Boilerplate and scaffolding are a good part of why 80 hours is possible at all. The setup follows best practices we would apply by hand, and it is done before anyone writes a line of the product itself.

Loops, not a pass. The reviewers do not approve or reject and then stop. They find problems, assign them back to be fixed, and keep going until there is nothing left to send.

The last step is the one that matters most. No agent commits to production. A person does, by name, every time.

None of this is the same activity as someone building a tool over a weekend with an AI assistant. Same technology, opposite discipline. We built this workflow for client code, where getting it wrong is expensive, and we did not loosen it to build something for ourselves.

The spec had been writing itself

The discovery phase was minimal, because each department knew exactly what slows them down when using Clockify and what features they would expect.

Years of adjusting or working around a tool that did not fit had produced a pretty clear requirements list.

Finance required a bit deeper dive due to the details of billing & payment processes. Other Teams also submitted feature requests that would make their lives easier.

That is worth saying plainly, because it is probably true where you work too. The workarounds your team has built are a specification, and a better one than a discovery workshop produces, because they were written by the people doing the work, under real conditions, over years.

So we built around the processes instead of the other way round. Projects sit under the accounts and clients they belong to. Retainers are a real thing in the system rather than something you rebuild from an export. User hierarchy, roles and permissions were part of the design from the first day rather than a pricing tier, which is why each department ended up with its own view. And the reporting was built backwards. We started from the report payroll and client billing needs, then designed the data model to produce it.

Built for our team

That is not a criticism of any particular product. Software built for thousands of companies gives everyone roughly the same screen.

Ours doesn’t.

Roles and permissions are part of the design - not a pricing tier. One system, different views, built around how each team actually works.

Finance. One click and payroll comes out in the format Finance needs.

HR. PTO is now one view, and the numbers belong to the system rather than to a spreadsheet

Account management. Retainer sits against the client and the account.

Project managers. Now can manage project team and their tracked time

Monthly cost breakdown

Build and payoff

The part we did not expect to matter as much as it does: about 105 people use it every working day, and the manual reformatting has not come back in any form. Not a smaller version of it, not a different workaround somewhere else. It stopped.

“Toward the end of the month, it was always a race against the clock. Manually checking data, correcting errors, and making sure everything added up for payroll. I’m glad that now, with Time Tracker, I can do it much faster and with less stress.”

Julia Mieszczak

Finance & Administration Specialist

“One of the most rewarding parts of launching Time Tracker was seeing people immediately ask for more. Every new feature request showed us that the system was solving real problems and that users wanted to make it even better.”

Janek Nowak

Senior PM & Frontend Developer

“The moment I saw how fast the team delivered our custom Clockify replacement, I put together a list of our next SaaS tools to replace.”

Paweł Kisiel

Managing Director & Founder

We started where it mattered. You can too

Most companies test a new way of building software on something low-risk. We did the opposite.

Our first tool handled the workflows at the heart of the company: time tracking, payroll, reporting, leave, client billing, and retainers. We rolled it out to 105 people. Because if we couldn’t trust it with payroll, we couldn’t honestly sell it to clients.

Experiencing it first hand made us realize how accessible and easy to ship software is in times of Agentic Engineering.

Remember that project you decided not to build because it was too expensive?

Revisit it. Building software that actually fits your process used to cost 10× more. Now look at the workarounds your team has built around software that doesn’t quite fit. Those workarounds are your requirements.

If you're reading this and thinking "I wonder, if…" - just reach out to Ala, share your ideas and pains and we'll give you an honest review. And who knows, you might be telling a story of how you've rebuilt your CRM, ERP or a vibe-coded app that needed tweaking on a budget and within an extremely tight timeline.

Which tool would you replace first?

Bring one idea, one tool you pay for or one thing your team does by hand.You will leave with an honest recommendation, which is sometimes to keep what you have.

Get in touch

Free · No pitch · No commitment

Meet the minds behind the project

We're the brains and the heart behind the code. A quirky bunch of passionate pros who love turning ideas into reality. Here, every project is a team sport, and we’re all about building software – and relationships – that last, one line of code at a time.