Every Project Starts with Confidence
At Lumitech, the Arq Decisions project began exactly as it should. A thorough discovery phase. Stakeholder workshops. Client document analysis. Several rounds of requirement refinement. Development paired with design from day one, so every requirement was backed by prototypes and high-fidelity mockups. Estimates were agreed upon, scope was signed off, and the team moved into active development.
It was the kind of professional kickoff that makes a Head of Delivery sleep well at night. Familiar. Methodical. Quiet.
And then, like most projects, it didn't stay that way.
The First Cracks were Invisible
Development followed Agile. Sprints, planning sessions, backlog refinement, regular demos. On the surface, the process was running smoothly. Then the feedback started coming in.
Clients reviewed working features during demos and requested changes. Those changes seemed small — a UI adjustment here, a logic tweak there. None of them looked like scope creep. Each was a sensible response to seeing the product taking shape. Each was the kind of refinement any reasonable team would accommodate.
But the product was already months into development, with deep interdependencies between modules. Each "minor" fix rippled across multiple areas of the codebase. A button moved meant rebinding events. A flow refined meant re-testing edge cases. A copy change meant translation passes.
No single change felt alarming. Cumulatively, they were devastating.
All these "insignificant" corrections led the project to a 70% overrun. And this is the reality most companies face — because problems only become visible in a report, or worse, in an invoice that now needs explaining.
Chief Product Officer, Tolmete
The Day X Moment
Several months in, the project manager finally sat down with the actuals. The team's hours, sprint by sprint, against the original estimate. The number that came back was 70% over budget.
Not from negligence. Not from poor engineering. From the accumulation of untracked, unscoped, change-request-free corrections that were absorbed silently into sprints. Friday-afternoon fixes that never became tickets. Client calls on Wednesday that turned into PRs by Thursday. Refinements made in the spirit of partnership, billed in the silence of margin loss.
And here's the part that mattered most: nobody had done anything wrong.
What happens next on a Time & Material contract is almost always painful. In the best case — somewhere between five and fifteen percent of clients — the client understands, accepts the hours, and margin stays protected. In the more common reality, there are disputes. The agency absorbs hours to preserve the relationship. Discounted invoices erode profitability. And in some cases, the partnership ends entirely.
This is not just a Lumitech problem.
It's an Industry Pattern
When the data came back, the team initially assumed they had missed something specific to Arq Decisions. Some unique pattern of client behavior. Some failure of their own discipline. The benchmarks said otherwise.
This is what scope creep looks like in every service business, in every industry, at every size. The fixes are small. The reasons are reasonable. The accumulation is invisible. And by the time anyone can see it, the conversation has already moved from "let's plan together" to "let's explain this invoice."
So We Rebuilt How We See
The root cause of the Arq Decisions situation was never the fixes themselves. It was that nobody saw them accumulating in real time. So Lumitech rebuilt how Tolmete fits into delivery. The platform now connects directly to Jira, GitHub and Slack, and continuously analyzes team activity against project scope. Instead of discovering problems at milestone reviews or invoice time, the team receives signals while there is still room to act.
Five signals run continuously across every active project. Each one has its own pattern, its own threshold, its own mitigation playbook. The story of how each became part of Lumitech's delivery rhythm is told in the chapters that follow.
Continue with Chapter 02
How Tolmete detects scope creep from Jira+Git
The technical pattern behind the signal that would have caught the original 70% overrun. Thresholds, false-positive handling, and $-impact math.
One Year Later
The 70% overrun on Arq Decisions was the last one Lumitech absorbed silently. It wasn't the last difficult project — that's not how delivery works. But it was the last one where the team had to discover, after the fact, where margin had gone. Now, the conversations have shifted. From "explain this invoice" to "here's what we caught on Tuesday." From defending hours to preventing them. From margin as a metric reviewed at quarter-end, to margin as something the team can see in real time.
The four chapters that follow each focus on one signal — how it works, when it fires, what we did when it fired on us. They can be read in any order. Or, if you want to keep moving, the next chapter waits below.
