TL;DR: This is the story of how we used AI to replace software we'd relied on for 11 years to track working hours, reporting to clients, and invoicing. What started as a discussion about how to deal with a 5× price increase turned into a working tool the whole company switched to in just four days. Instead of paying €3,000 a month, we now spend €124 on hosting, and we're getting ready to open-source it so other companies can use it too.

Why we stopped using a tool we'd relied on for 11 years

There were 2 moments that pushed us through the door.

Just to give you some context, we'd been using the same tool for 11 years to track how much time our team spent on client projects, plan workloads and prepare monthly reports for clients. It did its job pretty well, and we paid around €600 a month for it.

For the most part, we were pretty happy with the tool we were using.

But as time passed and technology advanced, we kept hoping the product would evolve too, especially when it came to automating the tedious task of manually writing down everything we'd worked on.

And this gets pretty annoying on a busy day, especially when you leave it until the end and have to remember what you actually did.

But we learned to live with it.

That was until one day we received the email that came with a "hefty" surprise.

Following an acquisition, the company behind the tool notified us that it was changing its pricing model. In short, on top of the flat subscription fee, they introduced a usage fee and several smaller charges.

So when we added everything up, our €600 monthly bill had suddenly jumped to around €3,000. 

That's roughly €7,000 a year turning into €30,000 to €36,000.

Naturally, we started discussing more affordable alternatives and told the team we'd be moving to another tool. But the team had a different proposal:

Since we'd already built a few internal tools using AI, why couldn't we also build this one ourselves?

A few days later we came up with the Farmer.

Meet Farmer, our new time-tracking and project reporting tool

Farmer is basically an AI-powered tool that helps companies like ours track how much time their engineers, designers and other team members spend on client projects, manage project costs and prepare accurate reports for clients.

After using the same software for 11 years, we knew pretty well what we needed from it and what we'd rather do differently.

And one thing we really wanted to change was how much manual work went into filling out timesheets, because let's face it, nobody wants to finish a day of work by trying to remember everything they did.

Project activities, Assemble…

Farmer takes the information that's already recorded throughout your workday and uses it to put together a timesheet for you.

It can pull meetings from Google Calendar, look at your development activity on GitHub and account for regular activities like daily stand-ups, which usually happen at the same time every day.

The idea was to save people the trouble of manually recording everything they'd worked on, while still giving them a chance to review their hours before submitting them, so they could spend less time on administrative work at the end of each day.

The feature that runs this operation is called Assemble my day, and it works on two levels.

Level one: calculating the hours

The first part is about making sure Farmer gets the working hours right.

We didn't want AI guessing how long someone had worked, especially since those numbers eventually end up in client reports and invoices.

So Farmer follows a set of rules to calculate the suggested hours.

For example, it only includes meetings you've accepted in Google Calendar, and if you have a regular meeting assigned to a project, it remembers that assignment.

It also accounts for your working schedule and the hours you've already logged, so it doesn't keep adding time beyond what you're supposed to work.

GitHub activity needs a slightly different approach because a commit or a code review doesn't tell you exactly how long the work took.

Farmer estimates that time using predefined rules, including a 30-minute estimate for each pull request review, and marks those entries as estimates so you can correct them.

And since these are still suggestions, Farmer shows where each entry came from.

You can review the hours, adjust the project or task, and leave out anything that doesn't belong in your timesheet.

Nothing is recorded until you approve it.

Level two: an AI assistant that works on top of it

Farmer has a built-in AI assistant, which lets every user make requests in natural language.

Now you don’t have to go through the timesheets yourself, you can just ask Farmer something like: “Assemble yesterday's timesheet and put the remaining hours on Harbor App."

The assistant will use the same rules engine we just described to prepare your timesheet, then make any adjustments you've asked for.

Before logging hours, you'll then be able to review the proposed entries and correct anything that doesn't look right before you add them to your timesheet.

Making sure Farmer is safe to use

Since you are handling the information about employees, projects and client work details, you also want a tool you could trust on project conversations.

That's why we had to be sure that the assistant follows exactly the same permissions as the web app.

For example, if you don't have access to a particular report, you won't be able to get it by asking the AI either.

And for bigger actions, like deleting records or changing someone's access, Farmer will ask for your approval before making the change.

We also had to account for the fact that the assistant will read information from outside the conversation, including meeting titles and GitHub activity.

That information could contain instructions that someone else has written, so we built in safeguards to prevent those instructions from being treated as commands.

Farmer from the Terminal

After we released Farmer, we discovered that some people wanted to use it without opening the web app at all.

One of our developers asked whether he could log his hours directly from the terminal, so we built a command-line version.

We also made the assistant's tools available through MCP, which means developers can connect Farmer to AI coding tools like Claude Code and use natural language to work with their timesheets from there.

Here is the close comparison between our old tool and the Farmer. Of course, it’s fair to say that the previous tool we used is a product built for a broad market, while Farmer is built for the way we work in Profico.

A side-by-side comparison of Farmer and our old time-tracking tool.

What it took to make Farmer production ready

Here's a quick look at the main milestones that got us from the idea to a production-ready version of Farmer.

Most of the work happened over the weekend, and we split it between Miro, who handled the business side, and Omar, who led the development.

• How we organize people into teams and distinguish between employees, students and contractors.
  
  

• Which hours count as billable work and which count as internal work.
  
  

• The monthly hour target each person is measured against.
  
  

• Who can see whose hours, from team members to Team Leads and project managers, and which reports project managers need to close out the month, including the detailed breakdowns they were used to.
  
  

• Which projects and historical records we needed to bring over from our old tool, and from what date.

For the technical side of work Omar played a huge part in designing Farmer's architecture and building the foundation, which included:

• The timesheet, where people could log and manage their working hours.

• The rules engine that uses Google Calendar meetings, GitHub commits and recurring activities to prepare suggested time entries.
  
  

• Importing our existing projects and time records from the old tool.
  
  

• Sign-in and permissions.
  
  

• The AI assistant and MCP server.
  
  

• Getting Farmer deployed and running.

As for the development process anyone can create an issue or open a pull request, and we usually resolve issues the same day.

That's the nice thing about having technical users.

They know exactly what they want and how to implement it, so once the code goes through a thorough review, we can get it up and running.

To give you a better idea of how quickly everything came together, here's what happened each day.

Building faster with AI doesn't mean skipping guardrails

When you hear that someone built something with AI “in a day”, it's easy to assume they rushed through development and cut a few corners along the way. 

But speed doesn't necessarily come at the expense of quality or security. With the right controls in place, it's possible to move faster precisely because there's a reliable process behind every change.

Here's how we put that approach into practice while building Farmer.

What's next for Farmer?

Getting Farmer up and running was just the beginning. Since the launch, we've continued improving it based on how people actually use it, and there are still plenty of things we want to add.

Some are already in review, while others will help us take Farmer beyond time tracking.

Here's what we're working on next:

• Native iOS and Android apps, along with a web app that feels native on a phone. Both are currently in review.
  
  

• A stronger AI assistant, with 25 additional tools and better handling of situations where an AI model stops responding.
  
  

• More tools for managing projects, including budgets, monthly client reports and invoices that reflect how we bill our clients.
  
  

• Absence.io integration, so approved time off automatically appears in Farmer's timesheet.
  
  

• Making Farmer open source. Our team enjoys using Farmer, and we think other companies could benefit from it too. We're preparing the code for a public release so other teams, including those facing the same price increase, can run Farmer on their own servers.

What we'll take from building Farmer

Building Farmer showed us that AI can make a much bigger difference than simply helping developers write code faster. 

It allows a small team to take on projects that would previously have required far more time and resources, and gives people outside development a chance to contribute their own ideas and expertise.

We also learned how important good engineering practices become when the pace of development increases. 

Clear requirements, code reviews and automated tests allow us to make changes quickly, catch problems early and keep improving software without sacrificing reliability.

For Profico as a company, the benefit goes beyond one internal project.

We now have firsthand experience of how AI changes the cost, speed and accessibility of software development, and we can bring those lessons into the work we do for our clients.