Shad Abbaslou / Contexts
● Open to UK roles
Deck 002 · Astrato, by Vizlib · three years · two delivery pods

Forty features. One product.

Forty features across two pods is a throughput number, and throughput is the least interesting thing about three years. The job was making them behave like one product. This is the deck, with the ticket behind the largest of them left in.

Joins routed around tables  not dragged through them. Drag one.

Role
Lead Product Designer · UX Engineer
Client
Astrato, by Vizlib · Snowflake-native analytics
Audience
Both pods, then product leadership
What this is
The deck, with the ticket left in
The problemA screen filed as a bugOverlapping join lines, one direction of connection, no zoom, on the canvas where every model in the product begins.
The moveTreat it as geometry, not stylingRoute around tables, connect from any side, snap to a grid. Four clicks to make a join.
The proofFour of five rated the task easyModerated sessions on tape with attention heatmaps, not a satisfaction survey.
01The platform

1,589 Snowflake connections, 860.6k queries

Astrato runs on the customer's own Snowflake warehouse and turns it into dashboards and answers. The numbers are off the product's own usage screen, which is the right place to establish what a design decision here is standing on: not a prototype, a platform with live data in it.

The Astrato workbook editor showing a usage-analytics dashboard: weekly active users, total Snowflake queries accumulated at 860.6k, 1,589 Snowflake connections, and a set of counters across the top, with the Astrato Insights assistant panel open over the charts.
The usage screen the platform figures come from.SHIPPED PRODUCT
02The teams

Two pods, 29 people, one designer counted twice

Preparation and visualisation were separate teams with separate roadmaps and no shared ceremony. A decision taken on one side arrived on the other as a chart somebody had to read, weeks later, with nobody accountable for the join between them except the person who sat in both stand-ups.

PREPTORS data preparation 9 head of product, head of engineering, six front-end developers, one designer VIZ-BEANS data visualisation 20 a project manager, twelve front-end engineers, two data scientists, four QA, one designer SEPARATE ROADMAPS SEPARATE CEREMONIES NOTHING CROSSES THIS except one person, marked in both blocks
The same person is marked in both blocks. That is the job.THE GAP HAD NO OWNER
Read this plate as text

Twenty-nine people in two blocks. Nine on data preparation: a head of product, a head of engineering, six front-end developers and one designer. Twenty on data visualisation: a project manager, twelve front-end engineers, two data scientists, four QA engineers and one designer. A boundary runs between them, because the two pods had separate roadmaps and separate ceremonies and nothing crossed it. The same marked cell appears in both blocks, which is the designer, counted twice, and is the whole shape of the job.

Preptors, ninehead of product, head of engineering, six front-end developers, one designer
VIZ-Beans, twentya project manager, twelve front-end engineers, two data scientists, four QA, one designer
The gap between themhad no owner, which is the job this role actually was
03The ticket

The problem arrived in Jira, not in a workshop

The join canvas is where analysts connect their tables before anything can be visualised. By 2023 its problems were on file, written by engineers, in the language of technical limitation rather than user experience. That framing is the reason the redesign was approved: nobody had to be convinced there was a problem, only that it was mine to solve.

Deck slide reproducing two Jira cards. VK-4532, technical limitation: no expand or collapse options, so developers must scroll through the workspace, making it difficult to find data; lack of zoom functionality, so users cannot zoom out, limiting navigation through complex diagrams; no indication of out-of-view tables, so users are unaware of tables not visible on the screen and connections may be overlooked. VK-4552, impact on users: BI developers and data analysts faced decreased efficiency, with difficulty in creating and understanding data relationships and productivity loss due to a confusing interface. Beside them, the live canvas with overlapping red join lines.
VK-4532 and VK-4552, as filed.SLIDE 03
"Messy overlapping join lines" VK-4532 · THE PROBLEM IN THE WORDS IT WAS REPORTED IN
04The diagnosis

Three constraints in the engine, three opportunities on the surface

Most of what made the canvas unreadable was not a styling decision anyone had taken. It was the renderer: one kind of join, one direction of connection, and a layout engine that gave every line the same lane. The design work was to understand those constraints properly and then design around them without asking for the engine to be rewritten first.

WHAT THE ENGINE COULD NOT DO WHAT THE SCREEN HAD TO DO ONE KIND OF JOIN every relationship drawn the same way REDUCE HUMAN ERRORS the model stops lying about itself ONE DIRECTION left to right, always, whatever the layout IMPROVE DIAGRAM CLARITY connect from the side that is nearest ONE LANE every line routed through the same corridor OPTIMISE NAVIGATION route around tables, not through them NO ZOOM, NO COLLAPSE a large model cannot be seen at once REPLACE THE RENDERER not affordable, and not attempted NOT TAKEN
Three constraints crossed. The fourth was refused.THE DIAGNOSIS
Read this plate as text

The join canvas ticket read twice, once as engineering and once as design, either side of one boundary. On the left, four things the renderer could not do: one kind of join, one direction of connection, one lane for every line, and no way to zoom out or collapse. On the right, the three briefs those became: reduce human errors, improve diagram clarity, optimise navigation. Three of the four cross the boundary. The fourth, which would have meant replacing the renderer, is drawn severed and marked not taken, because it was not affordable and was never attempted.

Working with the grain of the technology is not a compromise, it is the only version of this job that ships. The canvas got readable because the lines learned to route around the tables and connect from any side, which the renderer could be taught, and not because the renderer was replaced, which it never would have been.

05The geometry

The same model, before and after

Nothing in this pair is a restyle. The tables are the same tables, the joins are the same joins, and the second picture is readable because the lines stopped crossing things they have no relationship with.

Deck slide: a before and after comparison of the join canvas. On the left, the same data model with join lines crossing over tables they do not connect to, every line forced into the same horizontal lane. On the right, the same model with connections routed around the tables and leaving from whichever side is nearest, so no line crosses a table it is not joined to.
Before and after, same model, same joins.SLIDE 06
06On tape

The clutter was measurable, so I measured it

Moderated sessions were run through UserTesting with the real product, tagged live, and read back against attention heatmaps. The heatmaps are the part worth keeping: they show where people actually looked while trying to read a model, which is a different question from what they said about it afterwards.

The UserTesting notes and clips panel from a recorded session, with a timestamp field, a make-clip checkbox, positive and negative sentiment tags, and two saved notes against their timecodes, one of them recording that the objective of the task was to prepare data for consumer access and create visualisations.
Sessions tagged as they ran, positive and negative, against the clock.METHOD
Two attention heatmaps overlaid on the join canvas, showing concentrated attention on the left-hand data list and on individual table headers, with the join lines themselves attracting far less attention.
Where people looked while reading a model.ATTENTION HEATMAPS
07The result

Four of five rated the task easy. One did not.

This is the whole evidence base for the redesign, at the size it actually was. Five participants, one task, one difficulty question. Four put it at four out of five toward "very easy". One put it at three.

1 VERY DIFFICULT 2 1 of 5 3 4 of 5 4 5 VERY EASY 80% RATED THE TASK EASY four of five participants, one task, one difficulty question, moderated
The whole evidence base, drawn at its real size.FIVE PEOPLE
Read this plate as text

The difficulty question from the usability test, drawn at the size of its own sample. On a scale from one, very difficult, to five, very easy, one participant answered three and four participants answered four. Nobody answered one, two or five. Five people in total, which is the entire evidence base for the redesign and is drawn rather than described so that the sample size cannot be read past.

ONE QUESTION, IN PLAIN ENGLISH "WHICH TERRITORIES GREW LAST QUARTER?" 01 THE SQL read the generated query, visible and editable, for the analyst who will not trust a black box 02 THE SCOPE set which tables the answer is allowed to come from, as controls rather than syntax 03 THE SENTENCE say the result in plain language, because somebody has to paste it into an email 04 THE CHART see measures and dimensions resolved into a visualisation built from the real model FOUR READOUTS, ONE SOURCE
Four readouts of one answer. Take one.AUDITABLE BY DESIGN
Read this plate as text

One question asked in plain English, and four ways of reading the same answer. The generated SQL, visible and editable. The scope, as controls rather than syntax, deciding which tables the answer may come from. The result explained in a sentence. And the chart itself, built from real measures and dimensions rather than drawn. Four readouts of one source, so that nothing the assistant knows is available only to the assistant.

The deck this came from also carried a set of large percentage improvements: collaboration, adoption, time to insight, error rates. They are not reproduced here, and that is a deliberate omission rather than modesty. I cannot now say how any of them was measured or over what period, and a number whose derivation nobody wrote down is not evidence, it is decoration. What survives is the thing with a visible sample size and a chart underneath it.

Teams were independently replicating dashboards to meet specific needs. This led to redundant data views and increased costs. THE RESULTS SLIDE · THE BUSINESS CASE IN ONE LINE
08Astrato Insights

An assistant that shows its working

The hardest part of an analytics product is not running the query, it is knowing what to ask. Insights takes a question in plain language and returns a visualisation built from real measures and dimensions. The design decision that mattered was what it does next: it shows you the query it wrote.

Deck slide: the Astrato Insights panel, showing a typed question, the resulting measures and dimensions resolved into fields, and panels for refining the resolution of variables and fields.
A question, resolved into measures and dimensions you can see.SLIDE 08
Deck slide: four Insights panels showing how the scope of a question is refined, including selecting which tables to include or exclude from the answer and a natural-language explanation of the result.
Choosing which tables the answer is allowed to come from.SLIDE 09
SQL, if you read SQLthe generated query, visible and editable, for the analyst who will not trust what they cannot check
Filters, if you do notthe same scope decisions as controls, for the person who thinks in data rather than in syntax
Plain language, alwaysthe answer explained in a sentence, because somebody has to paste it into an email

Three depths on one answer is not three features. It is one decision taken once: the assistant is never allowed to be the only thing that knows why it said something. In a tool whose output ends up in a board pack, an answer you cannot audit is a liability wearing the costume of a convenience.

09The system underneath

New components only when necessary

Across three years and two pods I owned the component libraries for both products. The rule I held to was unpopular in roughly every sprint it applied to: a new component has to prove that no existing one can be stretched to fit, and most of the time one can.

Deck slide: component specifications for the join canvas controls, showing rows of join type selectors, toolbars and their states, each annotated with behaviour.
Join controls and toolbars, specified down to their states.SLIDE 10
Deck slide: a grid of around twenty shipped workbook and dashboard surfaces from across the platform, shown together as a sample of the forty-plus features delivered.
A sample of the surfaces, shown together so the consistency is checkable.SLIDE 11

Restraint is what keeps a system a system. It is also what made the grid of surfaces above possible: those surfaces were designed years apart by one person under one set of rules, and they sit next to each other without any of them looking like it came from a different product. That is the forty features behaving like one thing, which is the claim this whole deck exists to support.

Deck slide: two large end-to-end user flow diagrams for the data preparation journey, with decision diamonds, parallel branches and terminal states mapped across the full width of the slide.
The flows the surfaces had to satisfy, mapped before any of them were drawn.SLIDE 12
10The decisions

Four calls over three years, and what each one cost

The deck in its original form showed outcomes. These are the decisions underneath them, with the price of each written next to it, because a decision with no stated cost is one nobody had to take.

The canvas · 2023 Fix the geometry, and leave the renderer alone

The honest diagnosis was that the layout engine was wrong. The affordable fix was to teach the lines to route around tables and leave from any side, inside the engine as it stood.

What it cost The underlying constraint is still there. A model past a certain size still gets hard to read, and I shipped an improvement rather than a solution, which is the trade every designer inside a real codebase actually makes and very few case studies admit to.

Insights · the assistant The generated query stays visible

The simpler product is a chat box that returns a chart. Showing the SQL means showing the assistant being wrong, in public, in front of the analyst whose job it is to notice.

Why An analytics answer nobody can audit is worse than no answer, because it travels further. The cost was a more complicated interface and a more defensible one.

The system · across both pods Refuse new components by default

Every sprint produced a request for a component that already existed in a slightly different shape. The default answer was no, and the burden of proof sat with the request.

What it cost Being the person who says no to a team under delivery pressure, repeatedly, for three years. It is the least popular and most load-bearing thing on this page.

Working practice Talk to engineers daily, not at handoff

There was no handoff ceremony. Specs were written alongside the people implementing them, which is why the shipped product matches the design closely enough that the comparison is boring.

Why It costs the designer's time continuously rather than in a block, and it removes the moment where you get to blame the build. Both of those turn out to be the point.

11Outcome

The deliverable nobody writes down

29people across two delivery pods9 PREPTORS · 20 VIZ-BEANS
1,589Snowflake connectionsOFF THE PRODUCT'S OWN USAGE SCREEN
4clicks to create a joinDOWN FROM A MAZE
80%rated the redesigned task easyFOUR OF FIVE PARTICIPANTS

What I would tell another designer taking a role like this: the deliverable nobody writes on a job description is continuity. Two pods with separate roadmaps will produce two products unless one person is carrying the context across the gap every week, and that person has no authority to do it with, only the ability to notice early and to have already talked to both sides.

The join canvas is the part of this I am still proudest of, and it is the least fashionable thing here: no new technology, no visual flourish, a renderer left intact, and a screen that stopped lying about which tables were related to each other.

The case file carries the argument and the running workbook builder. Read case file 002, or use the rebuilt product.