build vs buy
By Saurav | Founder of saavos | Building in public toward $10k MRR
[!TLDR] Building an AI chatbot is a realistic weekend project. Maintaining one for 12 months isn't. Model-version drift, re-embedding after API changes, infra that scales with traffic, and your own time add up to a time-equivalent cost of $30k–$80k+ before you've shipped a single product feature. A managed platform costs $19–$99/month. This post lays out the full math — time, money, and opportunity cost — so you can make the call with your eyes open.
The API integration takes four hours. The production-ready system takes 150 hours. The v0.1 task list — chunking pipeline, embed widget, conversation logging, source ingestion robustness, security review, admin dashboard — adds up to roughly four weeks of full-time founder work. That gets you to "it mostly works in demos," not to maintained.
The Claude API chatbot tutorial takes about four hours. You get an API key, write a system prompt, wire in a context window, and you have something that answers questions. That part is genuinely straightforward.
The four hours stop being representative almost immediately.
Here is the real v0.1 task list, with honest hour estimates:
| Task | Hours |
|---|---|
| API integration + basic chat loop | 4 |
| Chunking pipeline (split docs into retrieval-sized pieces, handle edge cases) | 16 |
| Citation rendering (show users where answers came from) | 12 |
| Fallback handling (what the bot says when it has no good answer) | 8 |
| Embed widget (JavaScript snippet that loads on arbitrary third-party sites) | 24 |
| Conversation logging (store turns, session IDs, timestamps) | 16 |
| Source ingestion robustness (crawl errors, PDF parsing, encoding edge cases) | 32 |
| Security review (rate limiting, prompt injection, auth on admin endpoints) | 16 |
| Basic admin dashboard (view conversations, manage sources, monitor usage) | 24 |
| Total | ~150 hours |
150 hours is approximately four weeks of full-time founder work. That gets you to v0.1 — not to production-ready, not to polished, and not to maintained. It gets you to "it mostly works in demos."
For context: this is exactly the surface area that saavos and similar SaaS chatbot tools have already absorbed so you don't have to.
Realistic ongoing maintenance runs 10–20 hours per month, indefinitely. The five recurring costs: model-version drift (Anthropic ships new Sonnet versions every ~6 months, each requiring prompt re-testing), embedding model upgrades (re-indexing your entire vector corpus when OpenAI updates), infrastructure scaling ($80–$300/month by real traffic), abuse handling (prompt injection, rate limit breaches), and GDPR compliance on conversation logs.
The build cost is a one-time payment. The ongoing tax is where most DIY projects quietly break.
Model deprecation. Anthropic ships new Claude Sonnet versions roughly every six months. Each version changes behavior — sometimes subtly (tone, refusal thresholds), sometimes materially (context handling, system prompt interpretation). Your prompts were tuned against the previous version. When you upgrade, they need testing and often retuning. Budget 4–8 hours per model upgrade cycle, or accept quiet quality regression when you don't.
Embedding model upgrades. OpenAI has updated text-embedding-3-small and comparable models several times. When they do, the embedding space shifts: your stored vectors become stale relative to the new model, and retrieval quality degrades silently. Fixing this requires re-embedding your entire corpus — downloading every chunk, re-running it through the new model, re-inserting the vectors. If you have 10,000 chunks this is annoying. If you have 1,000,000 chunks, it is a multi-day project.
Infrastructure cost scaling. Vector databases are not free at scale. A few hundred documents is $0/month on a hobby tier. A few thousand documents with real traffic crosses into paid tiers quickly. Add Postgres for conversation logs, a CDN for the widget, separate compute for the ingestion pipeline, and Redis or equivalent for rate limiting. The bill that seemed trivial at zero traffic is $80–$300/month by the time you have real users — and you are the on-call engineer when it breaks.
Abuse handling. Once your bot is live, users will probe it for prompt injection. Some will use it to generate off-topic content. Some will hit it 500 times in a minute. Every edge case you did not design for is now your 2am incident.
GDPR and data-residency obligations. If any of your users are EU residents, you now have data controller obligations on the conversation logs. Consent banners, retention policies, right-to-erasure flows. None of this is glamorous work, all of it is legally required, and all of it takes time you are not spending on your product.
Audit logging. Enterprise buyers — even small ones — will ask for it. "Who asked what, when, and what did the bot say?" If you didn't build this in from day one, retrofitting it is a painful weekend project.
The cumulative ongoing maintenance for a conscientious team is 10–20 hours/month after v1.0. That is one to two and a half working days every single month, indefinitely.
At $150/hour, the 150-hour v0.1 build alone is $22,500 in time-equivalent. Add six months of 15 hours/month maintenance and you hit $36,000 in year one. Every hour spent on chunking logic or vector database migrations is an hour not spent on whatever your customers are actually paying you for. Pre-PMF, that trade is almost always wrong.
This is the one that most build-vs-buy analyses underweight.
Every hour you spend on chunking logic, prompt tuning, and vector database migrations is an hour you are not spending on whatever your customers are actually paying you for. Pre-PMF, that trade is almost always wrong.
The chatbot is not your product. The chatbot is support infrastructure for your product. Infrastructure is important, but infrastructure should cost you as little attention as possible so you can spend attention on the thing that actually creates value.
For a solo founder who values their time at $150/hour (a reasonable floor if you're raising or running a real business), the 150-hour v0.1 build alone is $22,500 in time-equivalent. Add six months of ongoing maintenance at 15 hours/month and you're at $22,500 + $13,500 = $36,000 in the first year. For a founder who values their time at $250/hour, that number is $60,000.
That math is not theoretical. It's the opportunity cost of whatever you did not build, did not sell, and did not learn because you were debugging a crawl pipeline.
See also: what saavos explicitly is not — the counterpart to this post, which names the tradeoffs on the SaaS side honestly.
Three scenarios justify DIY: you have retrieval requirements no SaaS supports (custom re-ranking over proprietary metadata, multi-modal embeddings — rare), the chatbot infrastructure is literally your product, or compliance rules forbid third-party SaaS entirely. Most pre-revenue SaaS founders do not meet any of these conditions. If none apply, DIY is an expensive detour.
This post is not an argument that building is always wrong. There are three scenarios where DIY is genuinely correct:
You have retrieval requirements no SaaS supports. Multi-modal retrieval over product images, custom re-ranking over proprietary metadata, hybrid semantic + keyword search over a domain-specific corpus — if your retrieval logic is part of your competitive moat, you probably need to own it. This is rare.
You are a chatbot company. If the chatbot infrastructure is literally your product — if you're building a chatbot platform, not using one — then yes, build. The engineering is the point. We built saavos; you probably aren't building a chatbot platform.
Hard compliance or data-residency requirements forbid SaaS. Some regulated industries (healthcare, finance, government) have requirements that prevent conversation data from leaving specific jurisdictions or touching third-party infrastructure at all. If your compliance counsel has confirmed this applies to you, the SaaS option is off the table regardless of cost. Most pre-revenue SaaS founders are not in this category.
If none of these three apply to you, DIY is probably an expensive detour.
At $150/hour, the 150-hour DIY build costs $22,500 — equivalent to 38 years of a $49/month SaaS subscription. Even cutting the estimate to 60 hours (optimistic), that is $9,000 in time-equivalent, over 15 years of subscription. The breakeven only tilts toward DIY when your ongoing maintenance cost is genuinely zero, your time is not the constraint, or your required feature set is unserved by any SaaS option.
At $19–$99/month, here is the breakeven calculation:
If you value your time at $150/hour, the 150-hour DIY build costs you $22,500. At $49/month SaaS, that is 38 years of subscription you could pay for with the same time budget.
Even if you accept the "this will be faster and cheaper than I think" optimism tax and cut the estimate to 60 hours, that is still $9,000 in time-equivalent — over 15 years of $49/month SaaS.
The breakeven tilts toward DIY only when:
Outside those conditions, the subscription pays for itself with the first hour of avoided DIY work.
Concrete example: if you spend 8 hours debugging a crawl pipeline edge case that would have been handled automatically by a SaaS ingestion system, and you value your time at $150/hour — that single debugging session ($1,200 in time) has already paid for 25 months of saavos Pro.
The full 150-hour surface area: chunking pipeline, embed widget, conversation logging, security hardening (rate limiting, prompt injection defense), source ingestion robustness, and a basic admin dashboard. Paste your URL, train the bot in minutes, embed anywhere with one script tag. Free tier is real — 50 messages/month, no credit card required to test training quality on your actual docs.
saavos exists because we built all of the above — the chunking pipeline, the embed widget, the conversation logging, the security hardening, the source ingestion robustness — so that you don't have to.
Paste your URL. Your bot is trained in minutes. Embed it anywhere with one script tag. The infrastructure that would take you four weeks to build v0.1 is live in five minutes.
If you're evaluating whether to build or buy, the starting point is saavos.com. The free trial is real. The honest answer to "should I build this myself?" is: you could, and it's your call — but here is exactly what that call costs.
Get the next post in your inbox
Honest writing on building, embedding, and shipping AI chatbots. No spam. Unsubscribe anytime.
The technical v0.1 build is roughly 150 hours of focused engineering work: API integration (~4 hours), chunking pipeline (~16 hours), citations (~12 hours), fallback handling (~8 hours), embed widget (~24 hours), conversation logging (~16 hours), source ingestion robustness (~32 hours), security review (~16 hours), and a basic admin dashboard (~24 hours). At a $150/hour time valuation, that is $22,500 in founder time before ongoing maintenance. The Claude API itself is cheap; the engineering surface around it is not.
Three recurring costs dominate: (1) model-version drift — Anthropic releases new Sonnet versions every ~6 months, each requiring prompt re-testing and tuning (4–8 hours per cycle); (2) embedding model upgrades — when OpenAI updates the embedding model, your entire vector corpus needs re-indexing; (3) infrastructure scaling — vector DB, Postgres for logs, CDN, rate limiting, and on-call engineering as traffic grows. Realistic ongoing maintenance is 10–20 hours/month after v1.0, indefinitely.
Three scenarios justify DIY: (1) you have custom retrieval requirements no SaaS supports — multi-modal embeddings over product images, domain-specific hybrid search, or retrieval logic that is genuinely part of your competitive moat; (2) you are a chatbot company and the infrastructure is your product; (3) compliance or data-residency rules forbid third-party SaaS vendors entirely. If none of these apply, the SaaS breakeven math almost always favors buying — even at $99/month, one avoided 7-hour debugging session pays for the first year.
At $150/hour, the 150-hour DIY build costs $22,500 — the equivalent of 38 years of a $49/month SaaS subscription. Even cutting the estimate to 60 hours (optimistic), that is $9,000 in time-equivalent — over 15 years of subscription. The breakeven only tilts toward DIY when your ongoing maintenance cost is genuinely zero, your time is not the constraint, or your required feature set is unserved by any SaaS option. Most pre-PMF solo founders do not meet any of those conditions.
At $150/hour, the 150-hour v0.1 build is $22,500 in founder time. Add six months of 15 hours/month maintenance and year-one cost hits $36,000. Pre-PMF, the chatbot is support infrastructure — it should cost you as little attention as possible so you can spend that time on the thing your customers are actually paying you for.
Rarely, for solo founders. The v0.1 build is 150 hours of engineering time — at $150/hour, that is $22,500 in opportunity cost before the first user session. Ongoing maintenance runs 10–20 hours/month. The three cases where DIY makes sense: your retrieval requirements are genuinely custom (multi-modal, proprietary hybrid search), the chatbot infrastructure is your product, or data-residency rules prohibit third-party vendors. If none apply, a $19–$49/month SaaS subscription covers the same job.
saavos covers the full 150-hour engineering surface: chunking pipeline, embed widget (one script tag), conversation logging, security hardening with rate limiting and prompt injection defense, source ingestion robustness for URLs and PDFs, and a basic admin dashboard for reviewing conversations and managing sources. Free tier is 50 messages/month with no credit card required — enough to test training quality on your actual docs before committing.
Builds tools for solopreneurs and small SaaS teams who don't have an afternoon to spare.
Paste your URL. Train your bot. Drop one script tag. No credit card.