It started with a simple question
How many hours go into a project, and which hourly rate may we bill for them? The answer depended on the agreements with each client, and it was spread across many places. The quote sat in Bexio or as a Word document and PDF, the project in Jira, the hours in Tempo, a Jira plugin. Before every billing run we brought everything together in Google Sheets, and the invoice was then created in Bexio again.
The real problem was not the number of tools, but the rules between them: which hours are billable and which are not, and which rate applies to which person in which project? That is exactly what we wanted to solve. In the end we built much more.
An example: the same work could be billed at two different rates in two projects, depending on the quote and the contract. Not every hour logged was billable, and not every person had the same rate in every project. These rules lived in people’s heads and in spreadsheets, and every billing run meant looking things up, matching them and asking around. It took time and invited mistakes.
Three attempts
The Cockpit was my own project in our move to working with agents, which I described in the previous article. The first attempt was thought too small, the second too big. Only the third got the foundation right: a clean data model for projects, people, rates and hours, on which everything else could be built. I built it with coding agents; the decisions on architecture, rules and sign-offs were mine.
What helped: I wrote every rule down in plain sentences first, before a single line of code existed, for example which rate applies to which person in which project and when an hour is billable. The agents turned that into code and tests, and I checked whether the result really matched the rule. Whatever did not went back. That way every function was traceable from the start.
Article
AI in everyday agency work: how Amar and Dennis changed the way we work
Two pioneers, three years of trying and a clear decision in summer 2025: how experiments became a way of working for the whole team.
What the Cockpit does today
For each project we see the budget from the quote next to the actual costs, broken down by task and person, with the billing rate and the cost rate. The margin is visible at any time, not only after billing.
How a billing run works today
- The quote is taken over into the project as its budget, line by line.
- The hours still come from time tracking in Jira and Tempo and are assigned to the tasks.
- Each person has a billing rate per project, with their cost rate next to it.
- The Cockpit separates logged and billable hours and calculates price, cost and margin.
- The billing is created from this data, without a detour through a spreadsheet.

The hours still come from time tracking, but they are shown per month and per person, split into logged and billable.

Because the data sits in one place, more parts followed: the pipeline with leads and their weighted value, the financial forecast for the year, plus clients, contracts, skills and HR.
The pipeline follows the stages an engagement goes through with us: new, analysis, qualified, estimation, review by client, contract sent, won. Each lead has a revenue and a probability, which give its weighted value. The financial forecast combines these weighted leads with the revenue from running projects. That way we see early whether a quarter will hold up, not only once it is over.


The Cockpit in motion
What this looks like day to day is shown in this short demo from the application: from the project through budget and hours to the overview.
More than ten tools in one place
Today the Cockpit covers what we used to need more than ten different tools for:
| Area | Before |
| HR | Personio |
| CRM | HubSpot |
| Knowledge base | Notion |
| Project finances and accounting | Bexio |
| Forecasting | Google Sheets |
| Project management and planning | Tempo Planner, BigPicture |
| Project hours | Tempo in Jira |
That does not mean these tools are bad. Each of them is good on its own. For an agency of our size, though, the sum was the problem: duplicate data, broken hand-offs and licences for everyone, even though many features are needed by only a few.
From an internal tool to cockpit.avidia.ai
When we told other companies about it, the same question kept coming back: can we have that too? That is why the Cockpit is now a product of its own at cockpit.avidia.ai, for agencies and service companies that want to manage projects, hours and rates in one place.
The Cockpit is multi-tenant: each company works in its own separate space, with its own projects, rates and people. What we need internally, we keep developing, and everyone who uses it benefits. In turn, requests from other companies feed back into our own work.
What we learned
- Start with the question, not the tool: our question was billing. Everything else came once the foundation was in place.
- The data model first: two attempts failed because the foundation was wrong. The third worked because it was right.
- Building beats stitching together more often today: with agents, a tool of your own is possible in weeks that used to be a large project. Responsibility for rules and data stays with people.



