Shad Abbaslou / Contexts
● Open to global roles
Case file 002 · Astrato, by Vizlib · three years · two pods

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.

Astrato · the workbook builder Rebuilt & running · fictional data
Open ↗
booting the product…

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.

On a phoneThe workbook builder The sheet keeps every object, stacked one to a row, and the data panel and the inspector move to tabs at the thumb: Sheet, Data, Inspect and More. Full screen ↗
The Astrato workbook builder on a desk: a usage dashboard of KPIs and charts, with the sheets and settings panel open on the right

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 ↗
A walkthrough, 28 seconds, recorded from the rebuild. The workbook, step by step: a filter, the data model, Insights answering with its SQL, the answer kept, the event log and the preview. Each step is captioned as it happens, and the transcript has the same words.
Transcript
  1. 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.
  2. 0:03 A click on one value in one object filters every object on the sheet.
  3. 0:06 A second click clears it.
  4. 0:08 The data model: tables joined on a canvas, from any side.
  5. 0:13 Insights, scoped to its fields, asked for MRR by region.
  6. 0:15 The SQL that produced the answer, open to edit.
  7. 0:18 Added to the sheet, the answer is an object the analyst owns and edits like any other.
  8. 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.
  9. 0:25 Preview shows the sheet the way a viewer will see it.
Role
Lead Product Designer
Client
Astrato, by Vizlib
Duration
Over three years
Scope
Both pods · three years
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 outcome4 of 5 rated the task easyModerated sessions with attention heatmaps, one thread of three years across both pods.
The problemA canvas filed as a bugJira VK-4532: messy overlapping join lines, one-direction connections and no zoom, on the screen where every model begins.
The moveFix the geometry, then prove itJoins route around tables, connect from any side, snap to a grid. Four clicks to create one.
00The blueprint

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.

SERVICE BLUEPRINTThe workbook builder as a service: sixteen moments from a connection to a published dashboard, with the join canvas as the moment of truth. Pan, zoom, pick a moment, count the clicks to any point, switch the sad paths on.
Wheel to pan, pinch to zoom, click a moment for its detail. ← → walk the moments, f fits the map.Open the blueprint full screen →
THE PLATFORM, END TO END: THE WAREHOUSE STAYS WHERE IT IS AND EVERYTHING ELSE READS FROM IT THE WAREHOUSE THE CUSTOMER’S SNOWFLAKE Pays by the second per question Nothing extracted, nothing stored Governance is the warehouse’s THE DATA MODEL DATA MODEL 1 · JOINS EDITOR Four tables, three joins Join type rewrites the SQL preview The row estimate moves with it THE WORKBOOK SHEETS AND OBJECTS Objects bound to fields Filters, variables, actions Every edit undoable THE VIEWERS DASHBOARDS AND EMBEDS The published version only Embed SDK, host-authenticated Filter bar, if published with one THE ASSISTANT INSIGHTS AND ANA Reads what the sheet shows Filters included Never the warehouse directly PUBLISH snapshot, audience, restorable INSIGHTS AND ANA READ THE SHEET, SO WHAT THEY SAY CAN BE CHECKED AGAINST WHAT IS ON SCREEN EVERY CHART COMPILES TO SQL THAT RUNS ON THE CUSTOMER’S WAREHOUSE, UNDER THE READER’S OWN ROLE
The warehouse never moves. The model sits above it, the workbook reads through the model, and nothing reaches a viewer that was not published on purpose.WAREHOUSE-NATIVE, DRAWN
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.

WHAT THE JOIN WORK WAS MEASURED ON, AND THE TWO USAGE FIGURES THE PRODUCT REPORTS ABOUT ITSELF A MODEL PEOPLE CAN READ 4 clicks to create a join after the canvas was rebuilt, down from a maze that forced every connection left to right JOIN CANVAS · VK-4532 4 of 5 RATED THE JOIN TASK EASY participants, each 4 out of 5 towards very easy, after the redesign USERTESTING · 6 MODERATED SESSIONS 6 MODERATED SESSIONS think-aloud, with attention heatmaps over the canvas; two of them in the deck at 26 and 20 minutes SESSIONS 4668969B AND 4668969E 1,589 SNOWFLAKE CONNECTIONS off the product’s own usage screen, the one the workbook on this page is built from GA TELEMETRY SCREEN 860.6k QUERIES SERVED on the telemetry screen alone; the queries tile on the Home sheet reads the same figure GA TELEMETRY SCREEN THE RESULTS SLIDE CARRIES MORE NUMBERS; THE ONES WITHOUT A STATED DERIVATION ARE LEFT OFF THIS PAGE
Two of the four are research measures and two are the product reporting on itself. The outcome section says which numbers from the results slide were dropped for having no derivation.MEASURED, THEN KEPT OR DROPPED
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.

WHAT THE DESIGN WAS BUILT FROM: EACH INPUT, THE FINDING IT GAVE, THE DECISION IT FORCED INPUT FINDING DECISION VK-4532 the Jira ticket: join lines crossed tables they had nothing to do with Every connection was forced left to right, and reading a model meant untangling it before using it. Rebuild the geometry, not the styling. Joins route around tables, connect from any side and snap to a grid. 6 moderated think-aloud sessions on UserTesting.com, with attention heatmaps Where people looked while building a join was not where the interface assumed they would. The clutter stopped being an opinion and became measurable, so it was prioritised. 144 fields in the assistant’s stated scope, declared before it answers An assistant that answers a data question with a chart asks people who query data for a living to trust a black box. SQL visible and editable at every step: Default, Block and SQL views of the same suggestion. 3 years on both delivery pods, nine Preptors and twenty Viz-Beans, one designer across both Features age. Most of what shipped has been restyled since; the structural work has not. Spend the design budget on structure. The join canvas outlived every dashboard trend it shipped beside. THE RESEARCH SECTION FURTHER DOWN CARRIES THE SESSIONS; THIS IS THE PART OF THEM THAT BECAME THE PRODUCT
A ticket, a research programme, a scope declaration and three years. Each one forced a decision that is visible in the running product above.INPUT · FINDING · DECISION
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.

The specAcceptanceVerified by

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

01The platform

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.

The Astrato workbook editor with the Insights AI panel open beside a dashboard
The workbook editor with the Insights panel open.WORKBOOK EDITOR
02The teams

Two pods, 29 people, one designer between them

The workbook builder with the version history open: every publish listed with who and when, and a restore on each
Two pods, one product: the history panel lists what shipped and when, across both delivery pods.THE PRODUCT, AS IT RUNS
FIG. 004 · BOTH PODS9 + 20 = 29 PEOPLE

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.

REBUILT FROM THE DECKTwo pods, one designer across both.

Preptors

Data preparation
Head of ProductHead of Engineering6 front-end devsme · the designer
9people

VIZ-Beans

Data visualisation
1 PM12 front-end engineers2 data scientists4 QAme · the designer
20people
03The join canvas

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
A DRAWING PROBLEM, FOLLOWED TO WHERE IT IS PAID FOR 01 A MODEL NOBODY CAN READ join lines cross tables they have nothing to do with 02 SO IT IS NOT TRUSTED a model you cannot follow is a model you cannot check 03 SO THE TEAM BUILDS ITS OWN faster than arguing about somebody else’s 04 REDUNDANT DATA VIEWS the same question modelled several times over 05 AND EVERY VIEW IS QUERIED against a warehouse billed by the second 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 · 4 OF 5 RATED IT EASY
An analyst who cannot read a model does not file a bug about it; they quietly build a second one. That is what the join canvas was costing, and it is why the redesign started with geometry rather than styling.UNREADABLE MODEL → DUPLICATE VIEWS → QUERY SPEND
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:

LIVE REBUILDThe geometry problem, rebuilt. Flip it.
CUSTOMERS customer_idregion_id ORDERS order_idcustomer_id LINE_ITEMS order_idproduct_id PRODUCTS product_idcategory REGIONS region_idname
A rebuild of the shipped geometry: the ticket's problems on one side, the fix on the other.CLICK THE TOGGLES
REBUILT FROM THE BACKLOGThe problem as filed.
VK-4532Join canvas · usability problemsLAST UPDATED 3/8/2023 · AFFECTS BI DEVELOPERS & DATA ANALYSTS
  • 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
Screen recording of the redesigned join canvas: joins routing around tables and snapping to the grid
The real canvas in motion: a screen recording of the shipped product.RECORDING · MAR 2025
04Research · 6 moderated sessions

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.

REBUILT FROM THE DECKThe research programme, and where it landed.
Sessions6moderated, on UserTesting.com
ProtocolThink-aloudwatching where the canvas surprised people
Recordings2 in the decksessions 4668969B and 4668969E, 26 and 20 minutes
HeatmapsAttentionwhere people actually looked while building a join
Task difficulty after the redesign4 of 5 participants rated it 4 / 5 towards "very easy"
Attention heatmaps overlaid on the join canvas from the testing sessions
Attention gathered on the data list at the left and on each table’s header; the join lines, the thing the canvas exists to show, drew far less. So the rebuilt canvas names each table’s joins under its header, where people were already looking.USERTESTING
The task, the question and the heatmaps, and what they found
Asked or watchedWithWhat it found
The task, as a session note records its objective: “prepare data for consumer access and create visualisations”5 participantsSet 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 participants4 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 heatmapsThe moderated sessionsOn 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
05Astrato Insights

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.

Astrato Insights with the Default, Block and SQL display toggle, showing suggested measures and editable SQL blocks
Default, Block and SQL views of the same suggestion.ASTRATO INSIGHTS
01 SCOPE THE FIELDS 144 fields the analyst chose, and the ask is bounded to them 02 THE PROMPT 1 plain-language question, no query language required 03 THE SUGGESTION 3 parts returned: measures, dimensions and the SQL 04 THREE VIEWS 3 the answer, its parts, and the SQL, all editable 05 INTO THE SHEET 1 object on the canvas. The query stays yours
The SQL is not a disclosure panel opened after the fact; it is present at every step, and editable.INSIGHTS · THE QUERY STAYS VISIBLE
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.

Seven seconds, recorded from the rebuild. Insights is opened and asked for MRR by region. It answers in its default view, four regions ranked, then shows the SQL that produced the answer, open to edit, with Add to sheet beneath it.
Transcript
  1. 0:00 The workbook editor.
  2. 0:01 Insights opens, scoped to the fields it may draw on.
  3. 0:02 Asked for MRR by region, it answers in its default view, four regions ranked.
  4. 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:

Showing the working, assistant by assistant
AssistantWhat it showsWhat the analyst can do with it
Snowflake Cortex AnalystThe SQL it generated for the questionEdit it, rerun it, and save the pair to a repository of verified queries the assistant draws on next time
ThoughtSpot SageThe search tokens the question became: the measures, attributes and filtersEdit the tokens; the documentation asks users to check them before sharing an answer
Power BI Copilot, in DAX query viewA DAX query, with commentsRun it, keep or discard it, and ask for it to be explained step by step
Astrato InsightsThe fields in scope, then the answer, its blocks and its SQL, as three views of one thingChange the scope, edit the SQL at any step, and add the answer to the sheet as an object they own
06System & handoff

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.

A component spec sheet with measurements and states, as delivered to engineering
A component spec sheet as it went to engineering.HANDOFF
Sixteen screens of the Astrato workbook editor arranged in a grid
Sixteen screens of the workbook editor, one system underneath.OVERVIEW
WHAT SITS ON WHAT SHEETS charts, filters, actions INSIGHTS 144 fields, SQL stays in view THE MODEL · THE JOIN CANVAS four clicks, joined from any side THE CUSTOMER’S DATA 1,589 Snowflake connections. It stays where it is: no extract, no copy 860.6k queries served live CONSUMER VIEW read-only, live data EMBEDDED inside another application
The model is the load-bearing layer: every sheet, every answer and both exits sit on it.SYSTEM · WAREHOUSE TO CONSUMER
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.

07The flow · end to end

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.

01 CONNECT 1,589 connections to warehouses that never move 02 THE CANVAS 4 clicks to join, from any side, and it snaps 03 THE SHEET 1 model underneath charts, filters and actions 04 ASK ANA 144 fields in scope, with the SQL in view throughout 05 PREVIEW 1 look at exactly what a consumer will get 06 PUBLISH 2 exits: read-only, or embedded THE CANVAS AS FOUND joins ran one direction, lines crossed the tables, there was no zoom and the model that everything rests on never got built at all
The whole model lives or dies at one decision: can an analyst read the joins they just made.CONNECT TO CONSUMER
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.

08What was broken · what changed

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.

The joins editor: four tables with three joins routed around them, the join type and the generated SQL beside the canvas
What moved, in the product: the joins editor as it runs today.THE PRODUCT, AS IT RUNS
What was broken, against what moved: the six rows of the table below, each crossed off by your scroll. Hold one to find it in the table.
Was brokenWhat I changedWhat it moved

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

09Outcome

Three years, one coherent product

Measured against the KPI tree in the blueprint
It worked ifResultStatus
A join takes a handful of clicks4 clicks, down from a maze that forced every connection left to rightMet
Analysts find the modelling task easy4 of 5 participants rated it easy, across 6 moderated sessions; a strong signal from a small sampleMet
The assistant’s answers can be checkedThe SQL stays visible and editable at every step of InsightsMet
The bill for duplicated dashboards fallsNot measured; the hindsight below says what I would change, and the plan after it howNot measured
29people across two pods9 PREPTORS · 20 VIZ-BEANS · ONE DESIGNER ON BOTH
1,589Snowflake connectionsOFF THE PRODUCT'S OWN USAGE SCREEN
4clicks to create a joinDOWN FROM A MAZE
4 of 5participants rated the join task easyON TAPE · USERTESTING

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.

The Insights panel over the home sheet: based on 23 fields, the question MRR by region, and the SQL it wrote shown in an editable view beside the Default and Blocks views
The outcome, running: Insights scoped to its fields, asked for MRR by region, with the SQL it wrote open to edit.THE PRODUCT, AS IT RUNS

What I would do differently

  1. 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.
  2. 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.
  3. 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.

The metrics, and where each is read
MetricHow it is worked outRead from
Query credits per sheet, weeklyThe credits each query a sheet runs is charged, summed by the tag the query carries, which names its workbook, sheet and objectThe 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 pairObjects added that show a measure and dimension the workbook already shows, of all objects addedObject Added, its repeats_pair
Answers keptInsights answers added to a sheet, of the answers givenInsight Added to Sheet over Insight Answered
Kept answers checked firstKept answers whose SQL was opened before they were kept; the guard on the other three, since the assistant exists to be checkedInsight Added to Sheet, its sql_viewed
The events, and what each one carries
EventFires whenProperties
Insight AskedA question is sent, typed, picked from the suggestions or arriving in a linksource typed, suggestion or link; scope_fields a number
Insight AnsweredInsights returns its measures, dimensions and SQLmeasures, dimensions, and left_out, the measures asked for but out of scope, each a number
Insight View ChangedThe answer is switched between its viewsview default, blocks or sql
Insight SQL EditedThe generated SQL is first changed by hand, once per answerNone
Insight Added to SheetAn answer becomes an object on the sheetsql_viewed and sql_edited, each true or false
Experiment ViewedSomeone in a workspace assigned to the test below first sees an answer, once per pageexperiment_id, experiment_name, variation_id and variation_name, as Segment’s A/B testing spec names them, each from a closed list
Object AddedAn object lands on a sheet, inserted, copied or added from Insightskind 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.

The design, fixed before any data
PartDecision
HypothesisOpening answers on their SQL raises the share of kept answers that were checked first, and does not lower the share of answers kept
Primary metricKept answers checked first, from the plan above
GuardrailsAnswers kept must not fall, query credits per sheet must not rise, and the split itself must hold
UnitThe 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
AnalysisPer workspace, the unit that was split; counting each answer as if it were independent would make the result look surer than it is
ExposureExperiment Viewed, once, when someone in a test workspace first sees an answer, so only people who met an arm are compared
LengthWhole weeks, at least two, so each arm sees every day of the working week
SizeSet 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.

Waiting for a count in each arm.
LIVE ARTIFACTThe full Astrato case study: the interactive site, with the join-canvas demo and UserTesting evidence inside it.
Enter the artifact full screen →

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