Ask any agency or studio where the month went, and you'll hear the same shape of answer: the work itself was fine — it's the hand-offs that bled. A scoped request became a Jira ticket that became a sprint that became a slack thread that became a spreadsheet that, on the 28th, became an invoice somebody had to reconstruct from memory.
Each of those arrows is a tool boundary. Every boundary is a place where context drops, where two people remember the same number differently, where a small approval the client gave verbally on Tuesday becomes the central fact of a billing dispute on Friday.
We've spent the last two years watching teams in the loop, and here's what we keep seeing: it isn't that any one tool is bad. It's that the work has to cross them, and the crossings are unmanaged.
The four leaks
When we sit with delivery leads and walk through a real month, the leaks fall into four buckets. They show up in nearly every engagement, and they compound.
1. Scope → estimate
The first leak is the easiest to miss because it happens before the work starts. A client emails a request. Someone in your team triages it — maybe replies, maybe scopes it, definitely thinks about it. Then someone else writes the estimate, separately. The thinking that informed the estimate doesn't travel with the estimate; it stays in a thread.
When the client later asks why the number is what it is — and they always do — your team reconstructs the reasoning. Sometimes they get it right. Sometimes they round down to keep the peace. Either way: unbilled time, every time.
2. Estimate → tracked work
Then the estimate is approved (often verbally, sometimes in a thread, occasionally on a PDF) and the work starts. Where? On the board, the tracker, the doc — somewhere the estimate isn't.
The result is a quiet drift: the work expands as it always does, the estimate stays where it was approved, and the connection between them is one person's memory. By release time, no one is sure which 60% of the estimate is left and which is gone.
3. Tracked work → invoice
This is the most expensive leak, because finance is now reconstructing what shipped from artifacts that weren't designed to bill from. Time entries are in one tool. The estimate is in another. The release notes — if they exist — are in a third. Somebody opens a spreadsheet on a Sunday and turns five tabs into one number.
We've measured this on real teams. The reconciliation alone runs eight to fourteen hours per release. That's hours that aren't billable, on top of the hours that didn't make it onto the invoice because someone forgot to log them.
4. Invoice → dispute
And then, sometimes, the client pushes back. Not always — most of the time they pay. But when they don't, the dispute travels backward through every leak you just papered over. The team scrambles to find the approval that justified the line item. The approval is in a thread. The thread is in email. The email is on someone who's on vacation.
What the client experiences is uncertainty. What you experience is a tax: hours spent defending a number that should have defended itself.
The hidden tax, sized
Here is the math we run with most agencies on a typical engagement:
- Two to four hours per release reconstructing scope-to-bill, conservatively.
- One to three percent of billable hours that never make it onto an invoice because the link to the work was lost.
- One in eight invoices that triggers a clarification round, costing roughly half a day of senior time each.
On an agency doing twenty releases a quarter and a million in services revenue, that's somewhere between sixty and a hundred thousand dollars a year — paid out of margin, in fragments small enough that no one notices any single one of them.
What "one record" actually means
When we say Align is built around one record, this is what we mean: the request, the estimate that priced it, the work that delivered it, the approvals that gated it, and the invoice that billed it are all the same object, read by different roles.
Your developers see a tracked entry. Your project lead sees a roadmap item. Your client sees a status in the portal. Finance sees a line item on a draft invoice. None of these are copies — they're views. When the work moves, every view moves. When the client approves the release, the invoice is already drafted, by construction.
That isn't an integration. Integrations connect two tools that each own their own copy of the truth. One record means there is no copy.
An audit you can run this week
You don't need to switch tools to find out what your hand-offs are costing you. Pick one engagement that closed last month and walk it backwards:
- Open the final invoice. Pick a line item.
- Find the work that line item represents. How many tools did you have to open?
- Find the estimate that the line item bills against. Is the estimate connected to the work, or only to your memory?
- Find the approval that authorized the estimate. Who approved it? When? Where is the record?
- Find the original request. How many people touched it before it became a tracked piece of work?
Count the tools. Count the threads. That's your hand-off surface area. Every joint on that walk is a place where hours leak, where context dies, and where a dispute, if it comes, will find you unarmored.
The goal isn't to add a tool that bridges the gaps. The goal is to have fewer gaps.
That's what we're building.