Your data already knows. Getting it out takes three days and an analyst.
Ask a question in plain English, get the answer with the query, the definitions and the caveats attached. Built on numbers your finance team has already signed off — so the answer matches the board pack instead of starting an argument about it.
Runs on your warehouse, in your infrastructure. No data leaves without your written sign-off.
—
—
Note what's on screen alongside the answer: the definitions it used, the query it ran, and anything it wants you to know before you quote the number. An answer you can't check is worse than no answer.
Writing the SQL was never the hard part
Models have been good at SQL for a while. What they can't know is that your company has four different definitions of the same word — and that three of them are wrong depending on who's asking.
"How many active customers do we have?"
Four correct answers. A generic tool picks one silently, and now your board pack disagrees with your CRM.
"What was revenue last month?"
These can differ by 40% in a growing business. Guessing which one someone meant is not a feature.
So the deliverable isn't a chatbot. It's an agreed definition layer — every metric written down once, signed off by the person who owns it, and used by every answer the system gives. The natural-language part is the easy half that sits on top.
Why the "chat with your database" demo doesn't survive contact
You've probably seen one. It worked beautifully. Here's what it wasn't showing you.
It was demoed on a clean schema
Well-named tables, no legacy columns, no
status_2 that superseded
status in 2021 but only for
accounts created after a migration. Your
warehouse doesn't look like that, and
neither does anyone's.
Nobody checked the answers against a known truth
A wrong number that looks plausible is the worst possible output, because it gets pasted into a deck and repeated. Unless someone verified the demo's answers against the finance system, the demo proved fluency and nothing else.
The questions were chosen to work
Simple aggregations over one table. The questions people actually ask involve time comparisons, joins across systems, and words like "churn" that carry an entire policy inside them.
It never said "I don't know"
A system that always answers will answer wrongly rather than refuse. If you haven't seen it decline a question, you haven't seen the feature that makes it safe to use.
Permissions weren't in the demo
Ask "what does each employee earn" and find out what your access model really is. Row and column-level restrictions have to be enforced before this reaches anyone, not bolted on later.
Four layers, and only one of them is the fun part
Understand what you've actually got
Profiling your warehouse or production databases: which tables are live, which are abandoned, where the same entity appears under three names, and where the joins silently drop rows.
Usually produces a list of data-quality findings worth fixing regardless of whether you go further.
The definition layer
Every metric that matters, written down once: what it means, which tables it comes from, which filters apply, who owns it, and when it was last agreed. Active customer. Churn. Revenue — all four kinds. Gross margin. Pipeline.
This is governed, versioned, and reviewable. When someone disagrees with a number, the conversation is about the definition rather than about whether the tool is broken.
This layer is the deliverable. Everything else is plumbing around it.
Query generation, constrained
The model doesn't write free-form SQL against your raw tables. It composes queries from the defined metrics and dimensions, which means the failure mode is "I can't answer that" rather than a confident wrong number.
Row and column-level permissions are enforced at this layer, mirroring whatever access model you already have.
The interface people actually use
In Slack, in your existing BI tool, or as a simple web app — wherever the questions are already being asked. Every answer arrives with the definitions used, the query run, and any caveats the system wants to flag.
Plus an evaluation set: a hundred questions with verified correct answers, run on every change, so accuracy is measured rather than assumed.
Definitions first, always
The workshop where four people discover they've been reporting different numbers is uncomfortable, valuable, and always happens.
Profile and interview
What data exists, what state it's in, and the twenty questions leadership actually asks. Collected from the people who ask them, not from a requirements document.
Agree the definitions
A workshop per domain, with the metric owner in the room. Output is a signed definition set — useful on its own even if the project stops here.
Build and verify
Semantic layer, constrained query generation, permissions. Every answer checked against your existing reports until they reconcile.
Release and hand over
One team first, then wider. Evaluation harness, runbook and a session with whoever owns data internally.
Published, so you can budget before booking a call
Start with the review. If your data isn't ready, that's a two-week finding rather than a four-month disappointment.
What state is your data in, and what do your metrics actually mean?
$7,500Two weeks · credited against a build
- Profile of your warehouse and key sources
- Data-quality findings, ranked
- Draft definition set for your top 20 metrics
- The conflicts we found, named
- Yours to keep and act on without me
The definition layer and the ask-anything interface on top of it.
$32k – $65k8–12 weeks · review credited
- Governed, versioned semantic layer
- Constrained query generation
- Row and column-level permissions
- Slack, BI tool or web interface
- Evaluation set with a measured accuracy bar
Definitions change, schemas drift, and someone has to keep it honest.
from $5,500/moCancel any month · 30 days notice
- New metrics and domains added
- Monthly accuracy report
- Schema-change monitoring and repair
- Model upgrades tested before they ship
- Your data team trained to take it over
The accuracy bar, and what happens if it's missed
Before the build starts we write 100 questions with verified correct answers — verified against your existing reports, by your own finance and ops people. The system has to hit an agreed percentage on that set before it goes to anyone.
If it misses, I keep working at my cost until it doesn't. That's affordable for me because the definition work happens first: most inaccuracy in these systems comes from ambiguous metrics, not from bad SQL.
Model and warehouse costs are billed by your providers directly, typically $150–$700 a month depending on query volume. Not marked up.
What data leads ask first
We already have Power BI / Looker / Tableau. Why is this different?
It isn't a replacement, and if your dashboards answer your questions you don't need me. The gap those tools leave is the question nobody built a dashboard for — which is most questions, because dashboards answer what you anticipated, not what you're wondering about on a Tuesday.
The other gap is the queue. Every ad-hoc question goes to a data analyst, gets prioritised behind four others, and arrives three days later when the decision has moved on. This doesn't replace your BI tool; it removes the queue in front of it. And it can be built on top of your existing semantic model if you have one — Looker's LookML or a dbt metrics layer is a real head start.
Our data is genuinely a mess. Are we too early for this?
Possibly, and the review will tell you honestly. But "our data is a mess" is what every company says, and it's usually less fatal than it sounds — what matters isn't tidiness, it's whether the numbers you care about can be derived reliably from somewhere.
The genuine blockers are different: no single source for a core entity like customer, or transformations that live only in someone's spreadsheet. Those need fixing first, and I'd tell you that in week two rather than month four.
How do we stop people making decisions on wrong numbers?
Four ways, all visible in the demo above. Answers only compose from defined metrics, so an undefined concept produces a refusal instead of a guess. Every answer shows the definitions it used. Every answer shows the query. And the system flags caveats — incomplete periods, unusual outliers, definition changes mid-range — before you quote the number.
Then there's measurement: the evaluation set runs continuously, so a drop in accuracy shows up as a number rather than as someone's embarrassment in a board meeting.
Can people ask about salaries or other restricted data?
Only if they could already query it directly. Permissions are enforced at the query layer against your existing access model — the system can't return rows or columns the asker isn't entitled to, and it says so rather than pretending the data doesn't exist.
Every question and every answer is logged, so you can audit what's being asked as well as what's returned.
Does our data go to OpenAI or Anthropic?
Your schema and definitions go to the model so it can compose a query. Whether your data does is a choice: the query can execute entirely within your warehouse and return only the aggregate result for phrasing, or not touch an external model at all if you run a local one.
That decision gets made in week one and written into the agreement, with contractual no-training terms where an external provider is involved.
What happens when someone changes the schema?
It breaks, loudly and immediately — which is the correct behaviour. The definition layer references specific tables and columns, so a rename fails a validation check rather than silently returning a wrong number.
The ongoing option exists largely for this. Schemas drift constantly in a growing company, and an unmaintained semantic layer decays into exactly the confusion it was built to fix.
Eight years of data pipelines where a wrong number cost money immediately
I'm Bahman Shadmehr. Automated trading platforms on the Texas wholesale power market and US equities, a national payment gateway I helped decompose while live, and the warehouses, pipelines and monitoring underneath all of it.
Trading systems are unforgiving about exactly this problem: a metric computed slightly differently in two places doesn't cause a debate, it causes a loss. That's where the insistence on defined, versioned, verifiable metrics comes from — it isn't a methodology I read about, it's a habit from work where the alternative was expensive.
You deal with me from first call to handover.
Python, Go, SQL, Athena, PostgreSQL, MongoDB, Redis, InfluxDB, Kubernetes, AWS, GCP. Remote, UTC+3. 76 technical posts, several on database design · LinkedIn
Send me the three questions your team asks an analyst most often
That's a better brief than any requirements document. I'll tell you within a day whether they're answerable from what you have — and which of them is secretly four questions wearing a trench coat.
info@bshadmehr.meUseful in a first message
- Where your data lives — warehouse, production DBs, spreadsheets.
- What BI tooling you already run.
- Three questions people ask an analyst repeatedly.
- Whether you have anyone owning data internally.
- Any constraint on data leaving your infrastructure.