Build governed data products visually
Drag sources onto a canvas, draw joins, attach policies, publish. Every flow exports to YAML and ships through Git — analysts move at design speed, engineers review at code speed.
postgres.customers
1.2M rows
oracle.invoices
4.8M rows
join · customer_id
left join
mask · pii
email · cpf · phone
publish
sql · rest · mcp
nodes
5
preview
12 rows
policy
pii.masked
version
v3 · draft
Visual at the surface, rigorous underneath
Every drag-and-drop change compiles to versioned YAML — review like code, ship like a product.
Drag-and-drop modeling
Pull a source onto the canvas, draw a join, attach a policy. The graph compiles to a governed view — no SQL required.
Live preview
Every node shows sampled rows, types and freshness inline. Catch breakage before you ship.
Versioned by default
Studio flows commit to a Git-backed history. Diff, branch, roll back — review changes like code.
From canvas to a published view
Four steps. Live preview at every node. No SQL detours.
Drag
sources · joins · filters · masks
Connect
draw lineage · auto-infer keys
Govern
attach policy · preview as role
Ship
publish · sql · rest · mcp
What you build visually, ships as code
Studio flows are YAML. Pull, edit, diff, push — same workflow your repo already has.
# customer_360.flow.yaml
nodes:
- id: src.customers
type: source
ref: postgres.core.customers
- id: src.invoices
type: source
ref: oracle.billing.invoices
- id: join.cust_inv
type: join
on: customer_id
inputs: [src.customers, src.invoices]
- id: mask.pii
type: policy
rules: [pii.masked, audit.all]
input: join.cust_inv
- id: out.view
type: publish
name: customer_360
channels: [sql, rest, mcp]
input: mask.piiStudio collapses the data backlog
Analysts ship governed views. Engineers review YAML. The data team unblocks itself.
// pattern
Citizen data engineers
Analysts ship governed views without writing SQL or Python. The visual canvas plus live preview turns 'I'll ask data' into 'I'll build it'.
// pattern
Rapid prototyping
Sketch a customer 360 in 20 minutes. Preview as a role, share a draft link, iterate before any code lands in main.
// pattern
Templates & playbooks
Promote proven flows to templates. Spin up customer_360, audit_trail or churn_signal as a starting point — then customize.
// pattern
Reviewable changes
Every flow change is a YAML diff. Reviewers see what columns moved, what policies changed and what consumers are affected.
A canvas that ships to production
Live preview, role switching, Git-native versioning — under one drag-and-drop.
<30 min
first governed view
Drag three sources, draw a join, attach a policy, publish. The whole loop fits inside a coffee.
Live
schema preview
Every node samples rows on render. Type errors and broken joins surface before you save.
YAML
exportable flows
What you build visually compiles to YAML — review in PRs, ship via CI, no lock-in.
Roles
preview-as switch
Toggle between admin, analyst and viewer perspectives in the canvas. See exactly what each role gets.
Questions about studio
What teams ask before adopting Studio as the modeling surface.
No. Studio compiles a node graph into a governed view definition that includes federation, masking, RBAC and publishing — things a SQL editor doesn't model. The canvas is the source of truth; SQL is one of the things it generates.
// ready to build
Sketch a governed view in 30 minutes.
Open Studio, drag two sources, draw a join, attach a policy, publish. A guided demo includes the full template gallery.