The demo takes fifteen minutes. Someone uploads a PDF, asks it three questions, and it answers all three correctly. The natural conclusion is that the whole thing is a week of work. Then the project runs eleven weeks, and nobody can explain where the time went. It went into the things nobody demos.
TL;DR
- A production chatbot takes 6–12 weeks for most SMBs. Narrow FAQ bots over clean content can land near 4; system-integrated bots run 12–16.
- Under a week of that is model work. The schedule is content preparation, integration, and testing.
- The most common delays are not engineering: messy documentation, a legacy system with no API, slow approvals, and mid-build scope changes.
- The fastest honest path to live is 2–3 weeks, and only with one narrow use case, clean content, no integrations, and a single decision-maker.
- ROI shows up 1–3 months after launch, not after kickoff. Deflection climbs during tuning; it does not start at its peak.
The short answer
Most AI chatbot builds take 6 to 12 weeks from kickoff to live customer traffic. That breaks into roughly 1–2 weeks scoping and content audit, 2–4 weeks build and integration, 2–3 weeks testing and grounding, and 1–2 weeks pilot and handoff. A narrow FAQ bot over already-clean documentation can finish in about 4 weeks; a bot that reads and writes to internal systems or touches regulated content runs 12 to 16. The model configuration itself is usually under a week. Schedule risk lives almost entirely in content quality, integration access, and approval speed — all client-side, all knowable before you start.
Phase 1: Scoping and content audit, 1 to 2 weeks
This phase produces no software and decides more of the schedule than any other.
Scoping means deciding, in writing, which questions the bot handles and which it refuses. That list is shorter than most teams expect and needs to be, because a bot that tries to answer everything is the bot that hallucinates. The output is an explicit in-scope and out-of-scope boundary that someone with authority has signed off on.
The content audit is where schedules are won or lost. Every document the bot will read gets checked for three things: is it accurate today, does it contradict another document, and does anyone own it. In most businesses this turns up surprises: a returns policy that exists in three versions, a pricing page that has not matched the contract since last year, a help center article describing a feature that shipped differently.
Fixing those is not chatbot work. It is documentation work that someone has to do before any bot can be reliable, and it is the single most common reason week two becomes week five. Businesses with a maintained help center clear this phase in days. Businesses whose knowledge lives in people's heads should budget two weeks and expect three.
Phase 2: Build and integration, 2 to 4 weeks
Now the software gets written, and the ratio surprises people.
Setting up retrieval, choosing a model, writing the system prompt, and wiring the conversation flow is a few days of work for someone who has done it before. The models are commodities; the patterns are well established. This is the easy part, and it is the part the demo showed you.
The rest of the phase is integration, and integration takes as long as your systems make it take. A bot that only reads documents is fast. A bot that has to check an order status, look up an account, create a ticket, or write a note into your CRM has to authenticate against each of those systems, handle their failure modes, and respect their rate limits.
A modern SaaS tool with a documented API adds a day or two per integration. A legacy system with no API, or an API someone built internally in 2019 and stopped maintaining, can add two to three weeks on its own, and occasionally forces a different approach entirely.
This is worth pricing before kickoff rather than discovering in week five. The chatbot developer cost breakdown covers how integration depth moves both the timeline and the number.
Phase 3: Testing and grounding, 2 to 3 weeks
Testing a chatbot is not QA in the traditional sense, because there is no pass/fail on a conversation. What you are building here is a measurement system.
The core artifact is an evaluation set: 100 to 300 real questions pulled from actual support tickets, each with a known correct answer, plus a deliberate slice of questions the bot should refuse. Every content change, prompt change and model change gets run against the whole set.
The first run is always worse than expected, and that is the point. Answers come back incomplete, over-confident, or drawn from the wrong document. Each failure traces back to something specific: a missing chunk, a bad retrieval boundary, a prompt that rewards helpfulness over accuracy. Then it gets fixed. Two or three cycles of this is normal.
Teams that skip or compress this phase do not save two weeks. They move those two weeks after launch, where the failures are visible to customers instead of to the team.
Phase 4: Pilot and handoff, 1 to 2 weeks
Launch to a slice, not to everyone. A quarter of traffic, or one channel, or business hours only.
The pilot exists because real users ask questions no evaluation set anticipated. They ask two things at once, they paste error messages, they open with context you did not know existed. A week of live traffic surfaces more edge cases than a month of internal testing, and it surfaces them at a volume you can still handle manually.
Handoff runs alongside: who owns the bot after launch, who reviews escalations, how content updates reach the index, and what the monthly cadence looks like. A bot without an owner degrades silently, over about two quarters, as content drifts and nobody re-runs the tests.
The full timeline, by build type
| Build type | Realistic timeline | What drives it |
|---|---|---|
| Narrow FAQ bot, clean content, no integrations | 3–4 weeks | Content is already accurate; nothing to connect |
| Standard support bot, 1–2 integrations | 6–10 weeks | One system to authenticate, moderate content audit |
| Support + sales bot, several integrations, write access | 10–14 weeks | Approval workflows, write-path safety, more testing |
| Regulated or compliance-sensitive build | 12–16 weeks+ | Legal review, audit logging, stricter constraints |
Free PDF · No fluff
The 2026 AI Development Rate Sheet
Real build, agent, RAG, and consulting rates by tier — the numbers vendors quote behind NDAs, in one PDF.
What causes delays
Across projects, the same five things push timelines. None of them are engineering.
Messy or missing documentation. Adds 1–3 weeks. The bot cannot be more accurate than the content it reads, so someone has to reconcile the contradictions first.
A legacy system with no usable API. Adds 1–4 weeks. Sometimes it forces a workaround, like a scheduled export or a middleware layer, that is slower to build and slower to run.
Slow internal approvals. Adds 1–3 weeks. Escalation rules, refusal language and tone need a decision from someone with authority. If that person has a full calendar, the project waits.
Scope added mid-build. Adds 2–4 weeks. "While we're at it, can it also handle renewals?" is a reasonable question that restarts phases one and three.
Compliance review scheduled late. Adds 2–6 weeks. Legal review discovered in week ten is the most expensive form of this, because it can invalidate design decisions made in week two.
How to compress the timeline honestly
The two fastest levers are both client-side: clean the content before kickoff, and name one decision-maker who can approve scope, tone and escalation rules without a committee. Together they routinely take two to three weeks out of a build. Adding developers does not, because chatbot projects are gated by decisions and data access rather than headcount.
What most people get wrong
The assumption that the model is the project. It is not. The model is a commodity that gets swapped in an afternoon, and every serious vendor is using something within a few months of the same capability. Choosing between them is a real decision but a small one, and it does not belong on the critical path.
The second mistake is treating launch as the finish line. Launch is the point at which you start learning what the bot is for. Deflection rates on week one are not the number you will end up with. They climb through the first month or two as real questions expose gaps, then plateau. Teams that measure ROI in week two conclude the project failed; teams that measure at month three usually see the opposite.
The third is trying to buy speed with people. Chatbot builds are gated by content decisions and system access, both of which are serial and both of which live on the client side. A second developer does not make the CRM API appear faster.
The bottom line
Plan for 6 to 12 weeks, and understand that only about one of those weeks is model work. The schedule is set by how clean your content is, how reachable your systems are, and how fast someone can make decisions. The timeline is largely determined before a line of code is written, and largely within your control. Audit the content before kickoff, name a single decision-maker, and confirm API access on every system in scope. Do those three things and the eight-week estimate holds. Skip them and the eight-week estimate becomes fourteen, and it will look like the builder's fault.
Next step: If you want a timeline estimated against your actual content and systems rather than a generic range, that's what the $497 AI Profit Leak Audit delivers. For cost rather than schedule, see how much an AI chatbot costs to build.
How long does it take to build an AI chatbot?+
A production AI chatbot for a small or mid-sized business typically takes 6 to 12 weeks from kickoff to live traffic. A narrow FAQ bot over clean existing documentation can land near 4 weeks. A bot that reads and writes to internal systems, needs approval workflows, or touches regulated content runs 12 to 16 weeks. The model work itself is usually under a week of that; the schedule is dominated by content preparation, integration, and testing.
Why does building a chatbot take longer than the demo suggests?+
A demo answers questions from a handful of clean documents with no integrations, no edge cases and no consequences. Production requires the opposite: every document audited for accuracy and conflicts, every system connected and authenticated, every failure mode handled, and an evaluation set proving it all still works after each change. The demo is roughly the first three days of a twelve-week project, which is exactly why demos are so persuasive and so misleading about schedule.
What is the fastest an AI chatbot can go live?+
Around two to three weeks, and only under specific conditions: a single narrow use case, help content that is already accurate and current, no integration with internal systems, a tolerant error profile, and one decision-maker who can approve without a committee. Configuring a hosted platform rather than building can compress this to days, at the cost of owning nothing. Anything faster than that is usually a pilot being described as a launch.
What causes AI chatbot projects to run late?+
Almost never the engineering. The recurring causes are messy or contradictory documentation that has to be rewritten before it can be indexed, a legacy system with no usable API, slow internal approvals on content and escalation rules, scope added mid-build, and compliance or legal review scheduled too late. Each of these adds one to four weeks, and all of them are on the client side of the project rather than the builder's.
How long before an AI chatbot shows ROI?+
Typically one to three months after launch, not after kickoff. The first few weeks post-launch are tuning: real questions expose gaps the test set missed, and deflection rates usually climb through that period rather than starting at their peak. Plan for roughly a quarter between go-live and a number you would defend in a board meeting, and measure deflection and escalation quality from week one so you can see the curve.
Free PDF · No fluff
The 2026 AI Development Rate Sheet
Real build, agent, RAG, and consulting rates by tier — the numbers vendors quote behind NDAs, in one PDF.
Written by
Pankaj Kumar
Founder · Metageeks Technologies
Metageeks builds production-ready AI products for $1M–$15M companies — shipped in fixed-price sprints, not open-ended retainers. We write about what actually works in the field.
Connect on LinkedInThe AI Build Brief
Ship AI that actually works.
Practical playbooks on building, pricing, and shipping production AI — one email, every other week. No fluff.
