Astrato, three years inside a data platform
What the workbook builder, join canvas and AI assistant of a Snowflake-native analytics platformFor data teams turning their own warehouse into models and dashboardsProblem the canvas where every model begins had been filed as a bug
Lead product designer across both delivery pods of a Snowflake-native analytics platform, for over three years, from the join canvas to an AI assistant that keeps its SQL in view.
20 min read · 14 min skimmed
Seven tables joins routed around them, not through them. Drag one.
Filter the dashboard, select an object and restyle it, ask Ana about what you are looking at.THE PRODUCT, NOT A PICTURE
Accessibility: The workbook builder passes axe-core’s WCAG 2.1 AA rules at desk and phone, in both settings, and in the 10 states this file links into. Not yet tried with a screen reader. The statement
Weight on a first visit: 343 KB of script and 13 KB of style, compressed, against budgets of 360 and 15 KB. The build fails if a product passes its budget. React Flow loads only when the data model is opened.
The states around it, each one a link: the warehouse not answering, a search that finds nothing and a sheet with nothing on it yet. Each says what is true, names the next step and offers one action.

The workbook builder works on a phone, with the inspector and the data panel as sheets. Open it full screen for the whole workspace.
Open the workbook ↗Transcript
- 0:00 The rebuilt Astrato workbook, with fictional data: sheets along the top, objects on the canvas, and the selected object’s settings on the right.
- 0:03 A click on one value in one object filters every object on the sheet.
- 0:06 A second click clears it.
- 0:08 The data model: tables joined on a canvas, from any side.
- 0:13 Insights, scoped to its fields, asked for MRR by region.
- 0:15 The SQL that produced the answer, open to edit.
- 0:18 Added to the sheet, the answer is an object the analyst owns and edits like any other.
- 0:21 The Events panel: each call the measurement plan in case file 002 records, checked against the plan as it is made. Nothing is sent.
- 0:25 Preview shows the sheet the way a viewer will see it.
- I owned
- Design across both delivery pods for over three years: the join canvas and its research, Astrato Insights, and the component libraries
- With
- Both delivery pods, 29 people: Preptors, data preparation, and VIZ-Beans, data visualisation, as the one designer across both
- Theirs
- The code, written by eighteen front-end engineers across the two pods, with two data scientists, four QA, a PM and the pods’ heads of product and engineering
- Constraints
- The customer’s own Snowflake warehouse, paid for by the second per question, with nothing extracted or stored and governance left to the warehouse; and one designer for two pods
- Friction
- The case for the canvas was the query bill, and the research measured how easy the task was; nobody instrumented the bill
The platform as a system, and the spec the rebuild is held to
Before the workbook builder: the platform end to end from the customer’s warehouse to a viewer’s screen, the numbers the join work was measured on, the evidence under each decision, and the spec the rebuilt editor passes on every release.
Read this plate as text
The platform drawn as five stations on one line: the customer’s own Snowflake warehouse, the data model with its joins editor, the workbook of sheets and objects, the viewers of published dashboards and embeds, and the assistant. Between the workbook and the viewers sits the publish gate: a snapshot with an audience, restorable later. A return leg says the assistant reads the sheet, never the warehouse directly.
The join canvas is the second station, and the reason the three-year file leads with it: everything to its right inherits the model. A join drawn wrong is wrong in every workbook, every published version and every answer the assistant gives, which is why the ticket that landed on the canvas was a platform ticket wearing a UI label.
The assistant sits off the main line on purpose. Insights and Ana read what the sheet is showing, filters included, and nothing else, so a reader can hold what they say against what is on screen. That is the design position from the AI section further down, drawn as a return leg.
Read this plate as text
A tree with one root and four branches. The root is four clicks to create a join after the canvas was rebuilt. The branches: four of five participants rated the join task easy across six moderated sessions, six sessions were run with attention heatmaps, and the product’s own telemetry screen reports 1,589 Snowflake connections and 860.6 thousand queries.
Read this plate as text
Four rows, each running input to finding to decision. The Jira ticket VK-4532 found that join lines crossed unrelated tables, so the canvas geometry was rebuilt. Six moderated sessions with heatmaps found that attention did not go where the interface assumed, so the clutter became measurable and was prioritised. The assistant’s stated scope of 144 fields came with the finding that a black-box answer asks too much trust, so the SQL stays visible and editable. Three years on both pods found that structural work outlives restyling, so the design budget went on structure.
The spec below holds the rebuilt editor to six statements. Each was written as an acceptance test before the screens were rebuilt, and each is verified by a check that runs before every release of this site, named in the right-hand column. Spec-driven in the plain sense: the sentence came first, the editor had to satisfy it, and something other than my eye confirms that it still does.
AS-01A join type change rewrites the SQL preview and the row estimate.
Given the joins editor, when a join is switched from left to inner, then the generated query says INNER JOIN for that table and the row estimate moves.
The checks “the joins editor draws the four tables” and “a join type change rewrites the SQL”.THE INTERACTION SUITE, RUN BEFORE EVERY RELEASE OF THIS SITE
AS-02A filter applies to every object on the sheet and says how much of the data is left.
Given the Home sheet, when a domain is clicked in the filter list, then every object restates and the filter bar reads the users in scope against the total.
The checks “a domain click filters every object on the sheet” and “Clear all removes the pills”.THE INTERACTION SUITE, RUN BEFORE EVERY RELEASE OF THIS SITE
AS-03Every edit to the workbook is undoable.
Given any change, when ⌘Z is pressed, then the workbook returns to the state before it and the status bar counts the changes held.
The checks “the title edit shows on the canvas” and “⌘Z undoes it”.THE INTERACTION SUITE, RUN BEFORE EVERY RELEASE OF THIS SITE
AS-04Insights and Ana read only what the sheet shows.
Given a sheet with filters, when Insights opens or Ana is asked, then every figure in the answer is one the sheet is showing under those filters.
The checks “Insights reads the sheet” and “Ana answers from the data”.THE INTERACTION SUITE, RUN BEFORE EVERY RELEASE OF THIS SITE
AS-05Publishing snapshots the workbook, and any version can be restored.
Given Publish, when a version is named and sent to an audience, then version history lists it and Restore loads it back onto the canvas.
The check “Publish writes v3”, and the Restore button in version history.THE INTERACTION SUITE, RUN BEFORE EVERY RELEASE OF THIS SITE
AS-06No join label is covered by a table or crossed by another join.
Given the data model, when it is drawn at any size, then every join label is clear of every table and every other join.
The canvas check over the joins editor, the same one that guards the two other canvases on this site.THE CANVAS CHECK, RUN BEFORE EVERY RELEASE OF THIS SITE
1,589 warehouses. 860.6k queries. One designer.
Astrato sits on the customer's own Snowflake warehouse, the database where a company keeps everything it has and pays by the second for every question asked of it, and turns that into dashboards and answers, 1,589 Snowflake connections and 860.6k queries served on the GA telemetry screen alone. I designed across all of it for over three years; what follows is the join canvas and the AI assistant, two threads out of three years of it.

Two pods, 29 people, one designer between them

One designer Counted in both blocks, which is the whole job
Nothing crosses the gap A preparation decision still arrives on the other side as a chart somebody has to read
A decision made on the preparation side turns up on the visualisation side as a chart someone has to read. Being the only designer on both pods meant carrying that context across: three years of making two halves feel like one product.
Preptors
VIZ-Beans
The problem arrived as a ticket. The fix was geometry.
The canvas is where analysts join their tables, telling the system that a row here and a row there describe the same customer, so a single chart can draw on both. By 2023 its problems were literally on file, in Jira.
"Messy overlapping join lines" JIRA VK-4532 · THE PROBLEM AS FILED
Read this plate as text
What an unreadable join canvas costs, as a chain of five consequences. One, a model nobody can read, because the join lines cross tables they have nothing to do with. Two, so it is not trusted: a model you cannot follow is a model you cannot check. Three, so the team builds its own instead, which is faster than arguing about somebody else’s. Four, which produces redundant data views, the same question modelled several times over. Five, and every one of those views is queried against the warehouse, which is billed by the second, so a drawing problem arrives as a bill. The business case was never the canvas; it was what the canvas cost when it did not work. The fix was the geometry, not a bigger warehouse: four clicks to a join, and four of five participants rated the task easy afterwards.
The redesign fixed the geometry first: joins route around tables, connect from any side, snap to a grid, and creating one takes 4 clicks. Flip the rebuild:
- Messy join lines, overlapping diagrams
- One-directional left-to-right line connections only
- No expand / collapse on tables
- No zoom on the canvas
- No indication that a table exists out of view

Four of five called it easy. I watched their eyes to be sure.
Think-aloud sessions on UserTesting.com, with attention heatmaps over the canvas, because where people actually look while building a join is not always where the interface assumes.

| Asked or watched | With | What it found |
|---|---|---|
| The task, as a session note records its objective: “prepare data for consumer access and create visualisations” | 5 participants | Set on the redesigned canvas, the one the product runs, where a join takes four clicks; one task and one question were the whole evidence base |
| How difficult was it, from 1, very difficult, to 5, very easy? | 5 participants | 4 of 5 answered 4, one answered 3, nobody answered 5 95% interval for 4 of 5: 36% to 98% A strong signal and a weak statistic, which is why the page never turns it into a percentage |
| Where people looked while building a join, from the attention heatmaps | The moderated sessions | On the data list and the table headers, much less on the lines; each table now names its joins under its header, and hovering one lights its line |
An AI assistant that shows its SQL
Pick the fields it may draw on ("based on 144 fields"), type a prompt, get measures, dimensions and SQL blocks back. The design position that mattered: the SQL stays visible and editable at every step. For people whose job is querying data, hiding the query would have broken trust.

Read this plate as text
How the Insights assistant answers without hiding its working. The analyst first scopes the ask to 144 fields, then writes one plain-language prompt. The suggestion comes back in three parts: the measures, the dimensions and the SQL that produced them. Three views are available at every step, the rendered answer, the blocks it was built from, and the SQL itself, all of them editable rather than read-only. What lands in the sheet is an object the analyst still owns.
Transcript
- 0:00 The workbook editor.
- 0:01 Insights opens, scoped to the fields it may draw on.
- 0:02 Asked for MRR by region, it answers in its default view, four regions ranked.
- 0:04 The SQL that produced the answer, open to edit, with Add to sheet beneath it.
How others show their working
Every assistant that writes queries for analysts has to decide how much of the query to show. What each of these shows, from its own documentation:
| Assistant | What it shows | What the analyst can do with it |
|---|---|---|
| Snowflake Cortex Analyst | The SQL it generated for the question | Edit it, rerun it, and save the pair to a repository of verified queries the assistant draws on next time |
| ThoughtSpot Sage | The search tokens the question became: the measures, attributes and filters | Edit the tokens; the documentation asks users to check them before sharing an answer |
| Power BI Copilot, in DAX query view | A DAX query, with comments | Run it, keep or discard it, and ask for it to be explained step by step |
| Astrato Insights | The fields in scope, then the answer, its blocks and its SQL, as three views of one thing | Change the scope, edit the SQL at any step, and add the answer to the sheet as an object they own |
Specs shipped as designed
Every new component is a maintenance cost someone pays later, so new ones appeared only when an existing one genuinely couldn't stretch. With eighteen engineers across the pods, precision in the spec was cheaper than conversations after the build.


Read this plate as text
Where Astrato sits. The customer’s own Snowflake warehouse stays where it is, 1,589 connections serving 860.6 thousand queries live, with no extract and no copy taken. The join canvas is the model, and it is the load-bearing layer: sheets and the Insights assistant rest on top of it, and both exits, the read-only consumer view and the embedded view inside another application, hang off it. Every sheet, every answer and both exits sit on that one layer, which is why reading the joins correctly matters more than anything else in the product.
Every dashboard in the product starts in the join canvas
The path from a Snowflake connection to something a colleague can open, and the decision that used to end the journey early.
Read this plate as text
End-to-end flow of Astrato. An analyst connects a Snowflake warehouse, one of 1,589, and the data never moves. On the join canvas the tables are joined in four clicks from any side, and the joins snap. That model sits under every sheet, with its charts, filters and actions, and under the Insights assistant, which is scoped to 144 fields and keeps the SQL in view throughout. Before publishing, the analyst previews exactly what a consumer will get. There are two exits: a read-only view and an embedded view inside another application. The route drawn and cut is the canvas as it was found, where joins ran in one direction only, lines crossed the tables, there was no zoom, and the model everything else rests on frequently never got built at all.
What the ticket said, and what shipped against it
Six problems from three years on the product, the mechanism used on each, and what changed afterwards.

Join lines crossed tables they had nothing to do with, every connection was forced left to right, and reading a model meant untangling it first. It was on file as VK-4532, affecting BI developers and data analysts.
Rebuilt the canvas geometry rather than restyling it: joins route around tables, connect from any side, and snap to a grid, and creating one takes four clicks.
4 of 5participants rated the join task 4 out of 5 towards “very easy” after the redesign.USERTESTING, 6 MODERATED SESSIONS
The canvas complaints were opinion, argued release after release, so nothing was prioritised.
Ran think-aloud sessions on UserTesting.com with attention heatmaps over the canvas, so what people looked at while building a join became evidence rather than a claim.
6moderated sessions, two of them in the deck at 26 and 20 minutes. The clutter stopped being an opinion and became measurable.SESSIONS 4668969B & 4668969E
An assistant that answers a data question with a chart asks people whose whole job is querying data to trust a black box.
Kept the SQL visible and editable at every step (Default, Block and SQL views of the same suggestion), and made the field scope explicit up front: “based on 144 fields”.
Insights shipped as something its users can check: nothing is returned that cannot be opened, read and rewritten by the analyst it was generated for.ASTRATO INSIGHTS, AS SHIPPED
A decision made on the data preparation side arrived weeks later on the visualisation side as a chart somebody had to read, because the two pods planned separately.
Being the only designer across both pods, I carried that context deliberately: one component system underneath both halves, and specs precise enough for eighteen engineers to build from without a follow-up meeting.
3 yrsof delivery across both pods, on one system rather than two.SCOPE FROM THE PROJECT DECK
Nothing told an analyst that a table existed off-screen, tables could not be collapsed, and there was no zoom, so large models were built half blind.
Zoom and expand/collapse on the canvas, plus an indication that something exists out of view, taken straight from the five problems listed in the ticket.
Reading the model stopped being a prerequisite for building one, which is what made four-click joins usable on a real warehouse rather than a demo.FIVE ITEMS ON VK-4532
Every new requirement arrived with a new component attached, and each one is maintenance somebody pays for later.
Owned the component libraries for both products and applied one test: a new component only when an existing one genuinely cannot stretch.
Specs shipped as designed. Three years on, the dashboards have been restyled by other people, and the join canvas, the structural work, is still the way the product connects data.HANDOFF SPECS, SHOWN ABOVE
Three years, one coherent product
| It worked if | Result | Status |
|---|---|---|
| A join takes a handful of clicks | 4 clicks, down from a maze that forced every connection left to right | |
| Analysts find the modelling task easy | 4 of 5 participants rated it easy, across 6 moderated sessions; a strong signal from a small sample | |
| The assistant’s answers can be checked | The SQL stays visible and editable at every step of Insights | |
| The bill for duplicated dashboards falls | Not measured; the hindsight below says what I would change, and the plan after it how |
The business case was never the canvas, it was what the canvas cost when it did not work: teams were independently replicating dashboards to meet needs the model could not express, which meant redundant data views and a query bill to match. Centralising that into the Data Explorer is the outcome the results slide led with, and it is the one a finance director understood without a design vocabulary. The deck carries the results slide, and says which of its numbers I have dropped for having no stated derivation.
Three years in one product teaches you something a portfolio of short engagements can't: features age. Dashboards get restyled, panels get renamed, and most of what I shipped in those three years has been touched by someone else since. The work that compounded was structural: the join canvas fixed how the product thinks about connecting data, and it outlived every dashboard trend it shipped alongside.

What I would do differently
- Spend more of the years on what does not age. Most of what I shipped in three years has been touched by someone else since; the work that compounded was structural. I would have moved to the model and the canvas sooner.
- Measure the bill, not only the task. The case for the canvas was the duplicated dashboards and the query bill they ran up, and the research measured how easy the task was. I would instrument the bill from the first sprint.
- Run more than five sessions before quoting a percentage. Four of five participants rating the task easy is a strong signal and a weak statistic.
The plan that line asks for
Written for this rebuild, after the fact, in the order Amplitude’s taxonomy playbook gives: what the work is for, the metrics that would show it, then the events those metrics need, named as Segment’s Track spec asks, an object and a past-tense verb. The rebuild runs it: every call is checked against the plan as it is made and shown in the product’s Events panel, and nothing is sent.
The objective is the one the business case named: fewer duplicated dashboards and a smaller query bill, without making the assistant’s answers any harder to check.
| Metric | How it is worked out | Read from |
|---|---|---|
| Query credits per sheet, weekly | The credits each query a sheet runs is charged, summed by the tag the query carries, which names its workbook, sheet and object | The warehouse itself: Snowflake’s query attribution history, grouped by query tag. It runs up to eight hours behind, so the metric is daily, not live |
| Objects repeating a pair | Objects added that show a measure and dimension the workbook already shows, of all objects added | Object Added, its repeats_pair |
| Answers kept | Insights answers added to a sheet, of the answers given | Insight Added to Sheet over Insight Answered |
| Kept answers checked first | Kept answers whose SQL was opened before they were kept; the guard on the other three, since the assistant exists to be checked | Insight Added to Sheet, its sql_viewed |
| Event | Fires when | Properties |
|---|---|---|
Insight Asked | A question is sent, typed, picked from the suggestions or arriving in a link | source typed, suggestion or link; scope_fields a number |
Insight Answered | Insights returns its measures, dimensions and SQL | measures, dimensions, and left_out, the measures asked for but out of scope, each a number |
Insight View Changed | The answer is switched between its views | view default, blocks or sql |
Insight SQL Edited | The generated SQL is first changed by hand, once per answer | None |
Insight Added to Sheet | An answer becomes an object on the sheet | sql_viewed and sql_edited, each true or false |
Experiment Viewed | Someone in a workspace assigned to the test below first sees an answer, once per page | experiment_id, experiment_name, variation_id and variation_name, as Segment’s A/B testing spec names them, each from a closed list |
Object Added | An object lands on a sheet, inserted, copied or added from Insights | kind one of the seven object types; source insert, copy or insights; repeats_pair true or false |
What is not collected matters as much. A question can carry a customer’s own figures, so its words never leave the page: a call records where the question came from and how many fields it could draw on, and no property anywhere holds free text, a field’s values or a row of data.
The test it makes possible
Insights opens each answer on its chart, with the SQL one click away. Whether opening on the SQL instead would make people check more without keeping less is a question a test can settle and an argument cannot. This design follows Kohavi, Tang and Xu’s Trustworthy Online Controlled Experiments. It was written for the rebuild, which has no users, so it has not run; both arms are in the product, as the chart first and the SQL first.
| Part | Decision |
|---|---|
| Hypothesis | Opening answers on their SQL raises the share of kept answers that were checked first, and does not lower the share of answers kept |
| Primary metric | Kept answers checked first, from the plan above |
| Guardrails | Answers kept must not fall, query credits per sheet must not rise, and the split itself must hold |
| Unit | The workspace, not the person. A workbook is shared, so one analyst’s object sits on a colleague’s sheet, and splitting people inside a workspace would put both arms on one screen |
| Analysis | Per workspace, the unit that was split; counting each answer as if it were independent would make the result look surer than it is |
| Exposure | Experiment Viewed, once, when someone in a test workspace first sees an answer, so only people who met an arm are compared |
| Length | Whole weeks, at least two, so each arm sees every day of the working week |
| Size | Set from the baseline the first weeks of the plan would measure, not guessed here |
The split, checked first. If the arms come out a different size from the even split the design asks for, the assignment or the logging is broken, and nothing else in the result can be trusted until the cause is found. The book calls this a sample ratio mismatch. Type the workspaces counted in each arm.
Source notes
- Join canvas problems and affected users from Jira ticket VK-4532, last updated 3/8/2023, shown above.
- Research material from moderated UserTesting.com sessions, videos 4668969B (26 min) and 4668969E (20 min), plus the six-session grid, heatmaps and results board, all from the project deck.
- Connection and query counts from product telemetry visible in the GA screenshot; data collected from Astrato GA, Dec 2021.
- Feature count, pod compositions, click count and the "based on 144 fields" panel are from the project deck.
- Full interactive case study: withcontexts.com/artifacts/astrato



