Introduction
Each month, four AI invoices arrive at Scalefast: Anthropic, Mistral, Scaleway, and OpenAI. They are accurate. They are also useless for the one question that matters when you run an eleven-person prospecting company: what does this feature actually cost me?
An invoice is a total per vendor per month. A feature is a cost per use per ticket. Between the two, there is nothing. The vendor has no idea that one call was used to generate an icebreaker for an SDR and another to analyze a meeting. It also has no idea that last week's $2,000 produced a complete training platform.
So we built what was missing. Twice, because a feature costs twice: once when you build it, and once when it runs.
1. What Runs: No Call Without a Task
The rule fits in one sentence: no call to a model goes out without its task name.
In practice, every LLM call in our app goes through a single layer. That layer requires a task drawn from a closed table: analyze_call, dialer_icebreaker, weekly_report, ops_triage, about thirty in total. Every usage line recorded carries that name. A line without a name is an anomaly, not a normal line.
A developer who calls the Anthropic SDK directly fails the CI. That is not a convention, it is a guard that counts direct calls and whose baseline is zero.
The task declares everything needed to manage it:
- the data class: internal, public, or client;
- the model required, and sometimes a candidate in A/B;
- the mode: batch or interactive;
- a monthly budget, where one makes sense. A per-task kill switch cuts without a deployment.
An Unpriced Cost Is a Hole, Not $0
This is the rule that has served us the most. The cost of a call comes from a rate catalog, per model, with the currency carried on the line. If a model is not in the catalog, its cost is NULL, never 0. Those lines surface counted separately, under the name unpriced_calls, and as long as any exist, the relevant component displays neither a net figure nor an ROI. A table that shows $0 for something that had a cost lies more than an empty table.
Sovereignty in All of This
Naming the task also gives you the data class, and therefore the right to route data outside the EU. An environment variable restricts tasks that touch client data to sovereign providers, Scaleway in euros today. Since our ADR-0024, a new task is sovereign by default; Anthropic remains an exception, proven and dated task by task. Proven how? Through a harness that replays the same real cases with the same prompt on both the champion and the candidate, and has the outputs judged by a model that belongs to neither family. Without per-task counting, this policy would be a wish.
2. What We Build: How We Tracked the Development of Our Internal Training Platform
The second cost is the one no vendor invoice can break down: the cost of building.
At Scalefast, we do B2B prospecting. For some that may seem far removed from tech, but the reality is that an SDR who cannot work with AI is a slow SDR. Not replaced, slow. So we decided to train the team for real. Not a webinar, not a list of prompts to copy: a platform where you learn by doing.
Short modules, screen by screen, with one action to complete at the end of each. It includes: a Prompt Lab that runs your prompt, shows the model output and grades it while citing its flaws; a virtual prospect that makes you practice your objections by voice; and a real training n8n instance where you build automations against CRM, email, and Discord stubs.
Raw numbers:
| Timeline, first message to last merge | 29 h |
|---|---|
| PRs merged to main, reviewed, CI green | 78 |
| Ticket sessions, plus one orchestration session | 61 + 1 |
| Parallel sessions at peak | 9 |
| Equivalent API cost | $2,374 |
| Tokens processed, including 11M output | 3.56B |
What that contains: 26 modules, 244 interactive screens, 78 lessons in three languages, 1,137 unit tests, 97 Playwright tests, 25 CI guards proven to turn red when you break the code.
The method is the same as in production: one unit of work, one name, one counter. Here the unit is the ticket. Each ticket had its own Claude Code session. The session carries its hours, its tokens, its cost. Git carries the lines and files from its PRs. Cross the two and you get one line per ticket:
- gamification, points, levels, badges: $80 and 2.3 session hours;
- the assistant that answers training questions: $70;
- the automation simulator: $3.44;
- orchestration, scoping, reviews, merges, deployment: $431 of the $2,374.
An average of around $30 per merged PR. We did not decide that, we read it.
The Comparison Estimate
What would the same work have cost done by hand? We do not know, and I am wary of people who do. We set an explicit rule: lines added and removed divided by senior developer productivity, plus fifteen minutes per file touched. At 60 lines delivered per hour, tests and content included, you get roughly 2,800 hours, or 400 person-days, or twenty weeks for a team of four. The actual timeline is 29 hours.
This rule is a dial, not a quote. It excludes scoping, reviews, manual testing, and deployment, which were added here just as they would be for a human team. And a human writes shorter code for the same functionality.
The Caveats, Written Before Anyone Raises Them
- The cost is what the API would have billed, as calculated by the platform.
- Sub-agents launched by sessions are not counted at this time.
- Infrastructure is not included: Railway, Scaleway, ElevenLabs.
These caveats are worth more than the number. A financial summary that does not say what it excludes is not a summary.
3. What Changes When You Manage by Cost
Three decisions became possible that were not possible with four invoices:
1. Cut. A task that exceeds its budget is visible; a kill switch cuts it without a deployment.
2. Switch. For each task, we project the cost of candidates: same tokens, catalog rate, without the cache discount from a vendor that does not offer one. A switch is decided on real judged cases, not on a list price.
3. Scope a ticket. When one build ticket costs $99 and another costs $3, the conversation about scope changes in nature.
The rule behind all of this is the same on both sides: a cost without a name does not exist for the person managing it. The vendor will never name it for you. Your code has to do it, before the call goes out, and your CI has to reject any call that does not.
What this system does not tell you: whether it is worth it. Cost is half of ROI, the easy half. The other half, value, is where you most want to cheat. That is the subject of the next article.
