Time-to-insight Reduced by 85% with a Natural-Language Interface

IMPACT

The natural-language system put data access directly in the hands of analysts. Questions that previously required a developer and a multi-day wait now resolve in seconds. The team makes decisions from data, in the moment those decisions need to be made.

CHALLENGE

The original workflow was a familiar one: an analyst needed data, submitted a request, and waited. A developer wrote a GraphQL schema by hand, built the query, ran it, and returned the result. Turnaround: days. For a team making operational decisions from data, that lag had a real cost.

The second phase addressed the manual schema work. We built an auto-generation layer that inspected the database at startup, built types and filter trees in memory using C# reflection and expression trees, and exposed a complete GraphQL API across a hundred-plus tables — no hand-written resolvers, no developer required for schema maintenance. It was technically sophisticated and genuinely effective.

But field-level business context — the descriptions, relationships, and domain meaning behind each column — still required manual documentation. As the underlying data structures changed, keeping that layer current became the new bottleneck. The system worked. Maintaining it required the kind of specialist knowledge that doesn’t transfer easily, and in practice, doesn’t transfer at all when the original team moves on.

SOLUTION

We replaced the translation layer entirely with an LLM-powered natural-language interface.

An analyst types a question in plain English. The system converts it to SQL, executes it against the database, and returns the result. There is no developer in the middle. There is no schema to maintain. Anyone on the team can use it from day one.

The decision was made with open eyes. We understood what we were trading: a system with precise, inspectable query logic for one where the translation step is a model call. We named the tradeoffs explicitly — query cost at scale, the need for caching strategies, the question of whether simpler queries could route to smaller models, and whether prompt design could reduce token usage without sacrificing accuracy. None of those were surprises. They were anticipated costs of a deliberate choice.

The original GraphQL architecture was the inverse: beautiful engineering with no exit plan. When the team that built it moved on, the system became effectively unmaintainable.