azyware
Business

How long does text to SQL solution take? A realistic timeline

EZ
Eazyware
· 7 min read
Quick answer

How long does text to SQL solution take?

A scoped text to SQL solution takes eight to twelve weeks from kick-off to a governed first release. Three of those weeks are question inventory and semantic modelling, four are build and evaluation, and two to three are shadow running with your analysts before anyone trusts an answer.

A scoped text to SQL solution takes eight to twelve weeks from kick-off to a governed first release. Roughly three weeks go on question inventory and semantic modelling, four on build and evaluation, and two to three on shadow running alongside your analysts. Broader schemas, unagreed metric definitions or multi-tenant row-level security push it to sixteen.

That range is the honest one, and the variance in it is almost entirely about your warehouse rather than about the model. Below is the week-by-week shape of a delivery, what genuinely runs in parallel, the five things that add weeks, and the two shortcuts that are worth taking when a date is fixed.

The week-by-week shape of a delivery

Every text to SQL engagement we run has the same five phases. What changes between a nine-week build and a sixteen-week one is how long phase two takes, because that is where your data model gets honest.

PhaseTypical durationWhat has to be true to leave it
Question inventoryWeek 1A ranked list of 40 to 80 real questions from the request log, with owners
Semantic modellingWeeks 2 to 3Every metric in scope has one agreed definition and one owner
Build and guardrailsWeeks 3 to 6Read-only roles, row-level security, query cost limits, generated SQL shown in the UI
EvaluationWeeks 5 to 7A golden question set runs green in CI on every schema or model change
Shadow runningWeeks 7 to 10Analysts accept or correct answers; acceptance rate is stable and understood
ReleaseWeeks 10 to 12Named user group, adoption reporting, escalation path agreed

Week one looks less technical than people expect. We sit with the analysts who answer ad hoc requests today, export the request queue, and sort what comes back into questions the warehouse can answer, questions it cannot, and questions that are really three questions wearing a coat. That sorting is what produces a scope you can price, and skipping it is how projects arrive at week eight with a system that answers questions nobody asked.

Phases overlap by design. Build starts before semantic modelling finishes, because the first ten questions are usually the least contested. Evaluation starts before build finishes, because you want the golden set written by someone who has not seen the implementation. Only shadow running is strictly sequential, and compressing it is the single most expensive shortcut available.

What can run in parallel

Four workstreams genuinely overlap, and knowing which they are is how a twelve-week plan becomes a nine-week one without cutting anything that matters.

  • Question inventory and warehouse access. Your platform team can provision the read-only role and a query cost budget while the question list is still being ranked.
  • Metric definitions and interface build. Chat surface, query display and result rendering do not depend on which metrics are agreed.
  • Golden question set and implementation. Write the expected answers from the business side while engineers write the retrieval and generation path.
  • Security review and evaluation. Row-level security policies can be written and tested against the warehouse before the querying layer exists.
  • Documentation and shadow running. The runbook is written during shadow weeks, when you are learning what actually goes wrong.

What cannot be parallelised is metric arbitration. If finance and operations disagree about what active customer means, that is a meeting, not a sprint, and no amount of engineering capacity resolves it faster. dbt's documentation on its semantic layer makes the same point from the tooling side: metrics are defined once and queried consistently so every consumer reads the same number.

What adds weeks

Metric definitions that do not exist yet

This is the biggest single variable and it adds two to four weeks. If your warehouse has three revenue columns and no governed definition, phase two becomes a governance exercise with engineering waiting. The fix is to start the definition work before kick-off, not during. The semantic layer: why text-to-SQL needs one sets out what good looks like here.

Row-level security across tenants or regions

Adds one to three weeks. Enforcing permissions in the database rather than in the prompt is non-negotiable, and testing it properly means a matrix of user roles crossed against the question set. Row-level security for AI analytics covers the implementation patterns and the tests that catch leaks.

Schema breadth

Adds one to two weeks per additional subject area beyond the first two. Forty questions across orders and inventory is a different project from forty questions spanning orders, inventory, finance, HR and support.

Data quality that only surfaces under questioning

Adds one to three weeks and is the failure nobody forecasts. Dashboards hide bad data because they aggregate it; a natural language query cuts across the warehouse in ways nobody has tried before and finds the orphaned rows, the duplicated joins and the time zone that was never normalised to IST. Budget for remediation, because the alternative is a system that confidently returns a wrong number in its first week of open access.

Approval cycles

Adds two weeks in regulated environments. Security review, DPDP assessment and change advisory boards run on their own calendars. Book them in week one, not week eight.

A deployment target that is not the warehouse

Adds one to two weeks. Delivering answers into Slack or Teams, or into an existing product surface, is real integration work. Conversational analytics in Slack and Teams describes what that layer involves.

The two shortcuts worth taking

When the date is fixed, there are two legitimate ways to compress, and they work in opposite directions. The first is to narrow scope to a single subject area and twenty questions, which reliably lands a governed release in eight weeks. The second is to buy certainty before you buy the build.

A ten-day Sprint Zero at $3,250 or ₹2,00,000, credited against the build, produces the question inventory, the metric gap list and the security model before the clock starts. A three-week ProofRun at $6,250 or ₹4,00,000 goes further and proves the twenty hardest questions against your real schema, which removes the accuracy uncertainty that otherwise stretches evaluation. Both are on the pricing page, and both shorten the build phase by more time than they consume.

What is not a legitimate shortcut is skipping shadow running. The acceptance rate you observe in those weeks is the only evidence you will have that the system is safe to open up, and teams that skip it typically spend the saved fortnight twice over on trust repair.

Where a faster timeline is the wrong goal

If your warehouse is mid-migration, waiting is cheaper than building. Every table that moves during the project invalidates part of the semantic model and part of the evaluation suite, and you pay for the same work twice. The same applies when the analytics team is about to change its modelling tool: build after the move, not across it.

There is also a case where no timeline is right yet. Under about fifteen regular askers, a shared query library and better documentation deliver most of the benefit at none of the cost. We would rather tell you that in week one than deliver a governed system that four people use. Build or buy: the honest case for each works through the same decision from the procurement side.

What you need ready before kick-off

  • Twelve months of data request history, exported and roughly classified
  • A named owner for each metric that will appear in the first release
  • A read-only warehouse role and an agreed query cost ceiling
  • The list of user groups and what each is allowed to see
  • A decision on the delivery surface: web app, Slack, Teams or in-product
  • Two analysts available for four hours a week during shadow running
  • Security review and any DPDP assessment booked in advance
  • An agreed definition of what a successful first release looks like

Cost and team for the scoped build

A natural language data querying build runs from $12,500 or ₹8 lakh to $38,500 or ₹25,60,000 depending on schema breadth and governance depth. The Eazyware side is typically one data engineer, one application engineer and a part-time product lead; the client side needs an analyst who knows the warehouse and someone senior enough to settle metric disputes. After launch, a care plan from $1,000 or ₹68,000 a month covers evaluation runs on schema changes, with the AI add-on at $750 or ₹40,000 for prompt regression and cost monitoring. Full detail on what sits inside those numbers is in the 2026 cost breakdown.

The constraint that most often moves a date is not engineering capacity but the availability of the one person who knows why the warehouse is shaped the way it is. Every delivery has one. If that person is also running a migration, take the later slot; a project that has their attention for six hours a week finishes faster than one that has a larger team and their calendar invitations declined.

Text to SQL solution: a practical implementation guide walks through the build phase in engineering detail. Ask your database: building a safe natural-language analyst covers the guardrail work that sits inside weeks three to six, and golden question sets explains how to produce the evaluation asset that gates release.

Plan for twelve weeks, spend the first three on definitions rather than models, and the schedule will hold.

Frequently asked questions

How long does a text to SQL solution take to build?

▾

Eight to twelve weeks for a scoped first release covering forty to eighty questions across one or two subject areas. Sixteen weeks is realistic when metric definitions are contested, row-level security spans tenants or regions, or the scope covers four or more subject areas.

What is the fastest a text to SQL project can go live?

▾

Around eight weeks, with scope narrowed to one subject area and twenty questions, and only when metric definitions already exist. A ten-day Sprint Zero at $3,250 or ₹2,00,000 beforehand shortens the build more than it costs, because it removes the discovery work from the critical path.

Why do text to SQL projects run late?

▾

Almost always because metric definitions were assumed to exist and did not. Arbitrating what revenue or active customer means is a governance exercise, not an engineering one, and it adds two to four weeks. Security approvals booked late and mid-project warehouse migrations are the next two causes.