What It Actually Cost Me to Build a SaaS Application With AI
2.1 billion tokens, 6,119 API calls, countless iterations, and a surprisingly small model bill. Here’s how that compares with building EvidenceFit Studio traditionally.
2.1 Billion Tokens Later: What It Really Cost Me to Build EvidenceFit Studio
So, how much does it cost to build a SaaS app in 2026?
Traditionally, a SaaS application with the scope EvidenceFit Studio has reached could reasonably require hundreds of thousands of dollars in professional development work. My estimate for this particular product is roughly $250,000 to $600,000 CAD, depending on the team, rates, scope and amount of product discovery involved.
My AI development bill tells a very different story. So far, more than 2.1 billion model tokens and 6,119 DeepSeek API requests have cost me $27.32 USD.
That does not mean I built a SaaS application for $27.32. Hosting, subscriptions, infrastructure and, above all, my own time matter. But the enormous difference between the cost of AI compute and the cost of traditional software development is precisely what makes this experiment interesting.
Here’s how I got there.
I did not start building EvidenceFit Studio because I wanted to launch a SaaS company.
I started building it because I was tired of doing the same work over and over again.
Every time I found a job I wanted to apply for, I would take my resume, the job description and sometimes a cover letter and bounce between ChatGPT, DeepSeek, Qwen, AugureAI, Claude and Perplexity. I was manually comparing requirements, looking for gaps, rewriting bullets, checking whether I was overstating anything, tailoring wording, and then doing another pass to make sure the finished resume still sounded like me.
It worked. But it was slow. At some point I thought: why am I doing all of this manually? So I started building a tool for myself. That became EvidenceFit Studio.
I showed it to a few friends. They liked it. I gave them access. They started using it too.
Then came the inevitable comment:
You should let more people use this.
That was really the point where a personal tool started turning into a SaaS product.
And somewhere along the way, I realized I had accidentally created another experiment entirely.
I had enough usage data to ask a question I find almost as interesting as the product itself:
What would something like EvidenceFit Studio have cost to build using a traditional software-development model?
And, perhaps more importantly:
What did it actually cost me to build it with AI?
The answer is not $27.32.
But that number is where the story gets interesting.
What It Cost Me to Build a SaaS App With AI
As of this writing, my DeepSeek development usage shows:
-
6,119 API requests
-
2,116,682,940 tokens
-
$27.32 USD in API charges
Of those 2.1 billion tokens, roughly:
-
2.105 billion went through DeepSeek V4 Flash
-
11.45 million went through DeepSeek V4 Pro
That is an almost comical amount of model activity for twenty-seven dollars.
It is also worth understanding why the bill can be so low. DeepSeek prices V4 Flash input differently depending on whether the input is a cache hit or cache miss, with cache-hit input dramatically cheaper than fresh input. It also has separate output pricing and, as of August 2026, peak and off-peak rates. (DeepSeek API Docs)
So the token number by itself is not a proxy for what another person would pay. Prompt caching, input/output mix, timing, model choice and pricing changes all matter.
Still, this is real usage from building a real application.
And $27.32 is not even close to the most important cost.
2.1 Billion AI Tokens Cost Me $27.32. Here’s Why.
What are tokens?
When an AI model reads or writes text, it does not process whole words the way a person does. Instead, it breaks text into smaller units called tokens.
A token might be:
- a whole short word
- part of a longer word
- punctuation
- a number
- a fragment of code
For example, a sentence containing 20 words might use more than 20 tokens, and source code can consume tokens very quickly because every identifier, symbol, string and structural element has to be represented.
A common rough rule for English prose is that 1 token is about ¾ of a word, so 1,000 tokens is roughly 750 words. That is only an approximation. Code, JSON, logs and unusual text can behave quite differently.
The important part for this article is that tokens measure how much information is moving through the AI model.
There are usually two main kinds:
Input tokens are everything sent to the model, such as prompts, source code, previous conversation context, error logs and documentation.
Output tokens are everything the model generates in response, such as explanations, code, tests and analysis.
So when I say EvidenceFit Studio development consumed more than 2.1 billion tokens, that does not mean the AI wrote two billion words of code. It means roughly that amount of machine-readable text and context passed through the models during thousands of development interactions.
And this last sentence is worth including because it explains the seemingly bizarre economics:
Token count is not the same thing as cost. Different models charge different rates for input and output tokens, and cached input can be dramatically cheaper than fresh input.
That is why 2.1 billion tokens and a $27.32 bill can coexist without one of those numbers being a typo.
No, I did not build a SaaS application for $27.32
This is where a lot of AI-development articles become silly.
Someone spends $19 on an API, builds an MVP and announces:
“I replaced a $500,000 development team for twenty bucks.”
No, you didn’t.
The API charge is only the compute bill.
My actual cost includes several things:
AI tools and subscriptions.
ChatGPT is part of my daily workflow, along with the models and tools I use during development.
Infrastructure.
EvidenceFit Studio is now a hosted application. There is a production environment, PostgreSQL, persistent storage, authentication, domains and the usual collection of small infrastructure expenses that appear once something stops living only on your laptop.
My time.
This is by far the largest cost.
And then there is a fourth category that gets forgotten:
the cost of being wrong.
AI can generate code extremely quickly. It can also generate the wrong code extremely quickly.
I still have to test it, challenge it, reject it, reproduce bugs, decide whether the user experience makes sense and determine whether a technically valid solution is actually a good product decision.
So if I eventually add up every dollar I have spent, the answer will be a lot more than $27.32.
But it will also be nowhere near what the same scope of work would traditionally cost.
What 2.1 Billion AI Tokens Actually Built
This is where the comparison becomes more useful.
EvidenceFit Studio is no longer a form that sends a resume to an LLM and spits out rewritten text.
The current application includes a fairly substantial workflow:
Resume + Job Description → Pre-Analysis → Resume Verification → Evidence Clarification → Evidence Mapping → Tailored Rewrite → Drift Checking → Before/After Analysis → Export
There is also application history, authentication, account isolation, Google sign-in, PostgreSQL persistence, interview preparation, reporting, beta-access controls, admin functionality, file storage, deployment, security hardening and an increasingly large automated test suite.
A lot of those 2.1 billion tokens were not spent writing shiny new features.
They were spent doing the work software teams spend enormous amounts of time doing:
-
reading an existing codebase
-
tracing data flows
-
designing schemas
-
writing React components
-
building Node/Express APIs
-
migrating SQLite to PostgreSQL
-
creating tests
-
diagnosing regressions
-
auditing authentication boundaries
-
testing cross-account ownership
-
hardening URL fetching against SSRF
-
creating content-security policies
-
fixing stale browser state
-
reviewing database migrations
-
cleaning up user interfaces
-
arguing with me when one of my ideas wasn’t as good as I initially thought it was
That last one is important.
AI-assisted development is not particularly useful to me if the AI’s job is simply to say, “Great idea!”
I need it to tell me when the idea has holes in it.
A 73% match became 53%. Then 68%. Then 52%
One of the better examples happened only recently.
EvidenceFit Studio analyzes how well a candidate’s current resume supports the requirements of a particular job.
I ran the exact same resume against the exact same job description.
- The first result was: 73%
- I ran it again: 53%
- Again: 68%
- Again: 52%
Same candidate. Same resume. Same job description.
That is a serious product problem.
The final score calculation itself was deterministic. The variability was coming from the LLM stages before the calculation. Even with deterministic-looking settings, the model could extract or classify requirements and evidence differently from one run to another.
We could have kept tweaking the prompt and hoping the variation became smaller.
We chose not to.
Instead, the application now creates a cryptographic fingerprint from the normalized resume text, normalized job-description text and analysis-pipeline version.
If the underlying evidence has not changed, EvidenceFit does not ask the model the same question again.
It reuses the analysis.
That means an unchanged resume and job description cannot suddenly become a 52% fit simply because somebody clicked a button twice.
The fix involved a PostgreSQL migration, new server-side fingerprinting, API changes, client behaviour, backwards compatibility for existing analyses, tests for version invalidation and tests proving that an unchanged rerun makes zero additional LLM calls.
That is the sort of work hidden behind the phrase:
“I built it with AI.”
AI wrote a lot of the implementation.
But somebody still had to notice that 73 → 53 → 68 → 52 was unacceptable product behaviour.
The most expensive resource was not compute
It was judgment.
That is probably the biggest lesson I have taken from this project.
When development capacity becomes dramatically cheaper, the bottleneck moves.
I can generate code quickly.
What remains scarce is the ability to answer questions like:
-
Should this feature exist at all?
-
Is this user interface exposing implementation detail instead of helping the user?
-
Is this metric trustworthy?
-
Is this security error giving an attacker too much information?
-
Is this workflow confusing?
-
Is this code fixing the problem or merely hiding it?
-
Should an identical analysis ever be allowed to produce a different result?
-
Does this page look like something a person designed, or like every other AI-generated SaaS dashboard on the Internet?
Those decisions are difficult to automate because they depend on context, product intent and taste.
Recently I looked at one of the Pre-Analysis screens and realized it was showing large boxes confirming that the resume and job description had been extracted successfully.
Why?
The candidate already knew that.
They were looking at the analysis.
The important content was halfway down the page while implementation details occupied the prime real estate.
Technically, the page worked.
Product-wise, it was wrong.
That kind of distinction matters more as the cost of generating code approaches zero.
What Would This SaaS App Cost to Build Traditionally?
There is no honest way to put an exact replacement value on EvidenceFit Studio.
Software isn’t a bag of cement.
Two teams can receive the same requirements and produce very different products at very different costs.
But we can establish reasonable boundaries.
Government of Canada Job Bank data currently puts the median wage for a software developer in British Columbia at $52.40 per hour, with the high end at $84.13 per hour. For software engineers, the provincial median is $62.50 per hour, with the high end just over $99 per hour. Those are employee wage figures, not agency billing rates, and therefore do not include an employer’s full cost, benefits, management overhead or agency margin. (Job Bank)
UX work is another discipline. Job Bank currently puts British Columbia UX designer wages at a median of about $35 per hour, with the high end at $57.69. Again, those are wages rather than what a consultancy would charge a client. (Job Bank)
A traditional implementation of the current product would need some combination of:
-
product management/business analysis
-
UX/UI design
-
frontend engineering
-
backend engineering
-
database work
-
LLM integration
-
QA and automated testing
-
security review
-
DevOps and deployment
That does not necessarily mean nine full-time people.
A good senior developer can cover several of those areas. A small agency might use three or four people and bring specialists in as needed.
But the work still has to happen.
If a traditional build required somewhere around 2,500 to 4,000 professional hours, a blended effective cost of $100 to $150 per hour would put the project roughly in the range of:
$250,000 to $600,000 CAD
That is deliberately a range, not a claim that EvidenceFit Studio is “worth $600,000.”
The lower end could be achieved by a lean, experienced team with a well-defined specification.
The upper end becomes increasingly plausible when you add discovery, redesigns, QA, project management, security, deployment, rework and the inevitable “we thought this was done but found another problem” cycles.
Which brings us to another awkward part of the comparison.
I did not have a complete specification when I started.
I was discovering the product while I was building it
This matters enormously.
If I handed a software team a finished specification today, they would have a much easier job than I had when I started.
EvidenceFit Studio grew out of use.
I would build something, use it, find the irritating part, fix it, add another workflow, test it against a real job description and discover another assumption that didn’t hold.
That is not wasted time.
That is product discovery.
A traditional team bills for that too.
Every conversation that sounds like:
“Why is this button here?”
“What happens if someone logs out and another person logs into the same browser?”
“Why are we showing extraction diagnostics to a candidate?”
“What happens if a model produces four items when the schema only accepts three?”
“Should someone be allowed to run exactly the same analysis again?”
…eventually turns into design work, engineering work, QA work or all three.
AI compresses the implementation loop.
It does not eliminate the loop.
AI did not replace a developer. It changed the shape of the team.
I think this is where the “AI will replace programmers” conversation usually goes off the rails.
I have been a software developer.
I am not sitting here manually writing every line of TypeScript in EvidenceFit Studio.
But neither am I typing:
“Build me an AI resume SaaS”
and going for lunch.
My role has become much closer to orchestrating a miniature product organization.
At various points I am acting as:
- Product owner: What problem are we solving?
- Business analyst: What should happen in all the weird edge cases?
- QA: Can I break this?
- Security reviewer: Can another user access this record?
- UX critic: Why does this screen feel wrong?
- Architect: Where should this state live?
- Customer: Would I actually use this?
The AI systems can take on huge portions of implementation, investigation and testing.
But I still own the decisions.
That is the part I think gets missed when people reduce AI development to “vibe coding.”
How AI Reduced My SaaS Development Cost
The savings are real.
Iteration speed
I can discover a problem, trace it, implement a fix and get a testable version in a fraction of the time it would traditionally take to schedule, estimate and implement another development ticket.
Testing
One of the biggest surprises has been how much automated testing I can justify.
A solo developer will often tell himself:
“I’ll add the tests later.”
Later tends to be a fictional country.
With AI doing much of the mechanical work, comprehensive regression testing becomes much easier to justify.
Security
We’ve spent time on authentication boundaries, ownership tests, SSRF protection, CSP/security headers, credential handling and cross-account data leakage.
Those are not glamorous features.
They are also exactly the things you don’t want to discover after strangers are using the application.
Breadth
One hour I might be working on React.
The next problem is PostgreSQL.
Then DNS pinning.
Then OAuth.
Then CSS.
Then an LLM schema.
Then a Railway deployment.
Traditionally, some of those would involve different people.
AI gives a single product owner access to an unusual amount of technical breadth.
The Hidden Costs of Building SaaS With AI
It would be dishonest to pretend the curve only goes one direction.
AI generates mistakes at impressive speed too.
I’ve dealt with:
-
features that worked but shouldn’t have existed
-
duplicate UI
-
layouts that looked unmistakably AI-generated
-
brittle assumptions
-
regressions
-
context limitations
-
prompts that didn’t survive a paste correctly
-
an agent reaching its working limit halfway through a redesign
-
LLM schema violations
-
nondeterministic analysis
-
code that needed another security pass
-
solutions that were more complicated than the original problem
A good example happened during the current Pre-Analysis redesign.
The coding agent completed part of the page, realized the remaining component was large enough that it could no longer verify the work properly, and stopped.
The tests were failing because the old tests still described the old UI.
That was not a successful implementation.
It was, however, the correct behaviour from the agent.
I’d rather have:
“I cannot safely finish this within the current context.”
than:
“Done!”
followed by three hours figuring out what “done” damaged.
AI-assisted development still needs supervision.
Sometimes aggressively.
The economics are almost backwards
Traditional software economics revolve heavily around engineering labour.
Compute matters, but on many projects it is a small line item compared with salaries and consulting fees.
AI-assisted development changes that ratio dramatically.
In my case, more than 2.1 billion model tokens have cost $27.32 USD so far.
DeepSeek’s current pricing helps explain how that is possible. V4 Flash is specifically positioned as its lower-cost model, and cached input can be priced far below uncached input. (DeepSeek API Docs)
My limiting factor is not:
“Can I afford another million tokens?”
It is:
“Do I know what I want the system to do?”
That is a profound change.
When code becomes inexpensive to produce, poorly considered code becomes inexpensive to produce too.
The premium moves toward judgment, architecture, verification and product thinking.
So did AI save me $300,000?
Maybe.
But I would phrase it differently.
I did not receive $300,000 worth of free software-development labour.
Nor can I claim that a company would definitely have charged exactly $300,000 to create EvidenceFit Studio.
What AI did was make a project with the scope and multidisciplinary demands of a substantial commercial application economically possible for one person to pursue.
That is the interesting part.
The traditional model might look something like this:
More cash. More people. More specialization. Longer coordination loops.
My model looks more like:
Far less cash. Enormous founder involvement. Extremely fast iteration. Continuous verification.
Both have costs.
They simply put those costs in very different places.
The Biggest SaaS Development Cost I Haven’t Counted: My Time
I haven’t tried to calculate this precisely yet.
I probably should.
Because if I eventually say:
“EvidenceFit cost me $500 to build”
while quietly ignoring hundreds of hours of my own time, I’m performing exactly the accounting trick I criticize elsewhere in this article.
For EvidenceFit Studio specifically, my estimate of the traditional cost to build this SaaS app is approximately $250,000 to $600,000 CAD.
For illustration, consider the difference:
| Founder time | At $50/hr | At $100/hr | At $150/hr |
|---|---|---|---|
| 500 hours | $25,000 | $50,000 | $75,000 |
| 750 hours | $37,500 | $75,000 | $112,500 |
| 1,000 hours | $50,000 | $100,000 | $150,000 |
I am not saying I have spent 1,000 hours on EvidenceFit.
Those are examples to show why founder time must be included in any serious cost comparison.
When I eventually publish a more complete accounting, I want to include:
-
AI/API spend
-
ChatGPT and other subscriptions
-
hosting
-
domains
-
third-party services
-
estimated hours
-
actual cash outlay
Otherwise the comparison is meaningless.
Would I build the next one this way?
Without hesitation. But I would do some things earlier:
- I would establish the design language sooner.
- I would put automated tests around critical workflows earlier.
- I would treat security as a continuous workstream from the start rather than something you “do before launch.”
- I would create stronger persistent architectural documentation earlier.
- And I would be much more suspicious when an AI-generated interface looked polished on the first attempt.
AI has developed a visual accent.
Once you have seen enough SaaS sites with the same rounded cards, purple gradients, pill-shaped badges and perfectly symmetrical feature grids, you can practically hear it.
That is another lesson from this project: AI can accelerate taste. It cannot supply it for you.
What started as a tool for me became something else
I think this is the part I enjoy most.
EvidenceFit Studio began because I was applying for jobs and wanted a better process. I didn’t want to copy the same information between six different AI tools every time I found a position I liked.
So I automated my own workflow.
Then I gave it to friends.
Then they told me other people might want it.
And now I’m operating a hosted SaaS application, thinking about beta users, security boundaries, UX design, analytics, infrastructure and whether identical evidence should ever produce a different score.
That escalated rather quickly.
But it also illustrates something important about the current generation of AI development tools.
The interesting opportunity isn’t necessarily: “Can AI build my startup?”
A much better question may be: “What useful thing have I never built because it would traditionally cost too much to find out whether anyone wanted it?”
That is a very different economic equation.
And I suspect we’re only beginning to understand what it means.
The Final SaaS Development Cost So Far
At the time of writing:
DeepSeek API requests: 6,119
Tokens processed: 2,116,682,940
DeepSeek API cost: $27.32 USD
Approximate traditional build range: $250,000–$600,000 CAD, depending heavily on team structure, rate, scope and how much product discovery is included.
Actual total cost: still being calculated, because pretending my time is free would make for a better headline and a worse article.
I’ll update the numbers as EvidenceFit Studio moves through beta.
And if the DeepSeek bill eventually reaches $30, I may have to speak with Finance.
Special thanks to ChatGPT, DeepSeek and every other AI/LLM out there for taking my thoughts, ideas and putting them into something more coherent.