Skip to content

WIX 2026-07-28 Tier 3

Read original ↗

Wix Vizion: How a Tool I Built for My Team Became Wix's Official BI Platform

Summary

A first-person Wix Engineering narrative describing Vizion, an internal natural-language business-intelligence platform that grew from a personal side project into Wix's official BI tool, replacing a commercial product that cost ~$500K/year in licenses. A user describes a dashboard in plain English; an agent (fronted by multiple skills) writes SQL grounded by context from an MCP server, the query runs on live data through Trino (which federates every data source Wix owns), and the result renders as a real dashboard assembled from a curated component library. The engineering thesis is that generating the UI is now the easy part — the hard part is trust: an LLM will hand you a confident, beautiful, wrong number with no error. Trust is engineered into the delivery pipeline: every dashboard is code in Git (manifest + SQL + page), every change (human or agent) passes the same CI checks before going live, each team runs its own independently deployed service on its own Kubernetes pods that a central hub discovers and stitches into one experience, and anything touching sensitive data must name who can see it or it fails closed.

Key takeaways

  1. The gap was never the frontend — it was the wiring to live data. People could already generate good-looking dashboards locally, but they "lived on a laptop and were wired to nothing." Vizion's contribution is closing everything between a local mockup and a dashboard running on live company data. (Source: sources/2026-07-28-wix-how-a-tool-i-built-for-my-team-became-wixs-official-bi-platform)
  2. Three pre-existing pieces, newly pointed at one problem: Trino could query every data source Wix owns; MCP could give the agent the context around the data (what a table means) instead of just the data; serverless could turn it into a running service in an afternoon. None had been aimed at the same problem before.
  3. Trust is engineered into the pipeline, not the prompt. The author "stopped writing cleverer skills and built the trust into the pipeline, in the places the AI couldn't skip." A dashboard is just files in Git — a manifest, the SQL, and the page — and every change runs the same automated checks: the manifest must declare what it should; every SQL placeholder must be accounted for so a query can't run with a missing filter; components must come from the shared library; and every query must actually execute against live data and return something sane. Nothing ships without passing CI. (See ci-gated-dashboard-publish.)
  4. Per-team independently deployed services behind a central hub. "Underneath, each team is its own independently deployed service, running on its own Kubernetes pods, that the central hub discovers and stitches into one experience. The isolation is the point" — a team can ship, break, and fix its own dashboards on its own schedule without touching anyone else's. (See per-team-independently-deployed-service-with-central-hub and concepts/tenant-isolation.)
  5. The AI assembles from a curated component library, it does not freestyle markup. Letting an AI write raw HTML/CSS "gets you something different every time, costs tons of tokens, and most of it is fragile." Instead Wix designed ~30 tested, branded building blocks (KPI cards, data tables, filter bars, date pickers, sparklines, ~12 chart types) each already handling its own loading/error/empty states. "Now the agent doesn't invent a chart, it picks one" — turning generation into assembly of known-good pieces, which is what an LLM is reliable at. (See ai-assembles-from-curated-component-library.)
  6. Publish == open a PR; auto-merge when safe. "When you publish, you open a pull request, the checks run, and a real problem comes back as a violation with a plain explanation of how to fix it. If everything passes and it's just a dashboard, it approves and merges itself and deploys automatically, live a few minutes later." Changes to the platform itself still wait for a human, and anything touching sensitive data must name who can see it "or it fails closed." (See natural-language-over-git-workflow and patterns/default-on-security-upgrade.)
  7. A side project erased a ~$500K/year line item. Once it became too important to stay a side project, a team of engineers, designers, and data people spent a focused month hardening the platform and pushing performance "until it could carry the whole company." Vizion became Wix's official BI platform and replaced the legacy tool, whose per-build-and-per-view licenses cost ~$500K annually.
  8. The discipline is invisible to the user. "Someone who just wanted a funnel chart gets the full discipline of professional software delivery — version control, continuous integration, isolated deployments, automatic review — without ever learning that any of it is there."

Systems / concepts / patterns extracted

Systems

  • Trino — the federated distributed SQL engine behind Vizion; queries "every data source we own" so generated SQL runs against live data without relocation.
  • Model Context Protocol (MCP) — supplies the agent with context around the data (table semantics) so it understands what a table means "instead of guessing," grounding SQL generation.
  • Wix Vizion — the natural-language BI platform itself (no dedicated page created; a single-source internal product).
  • Kubernetes — each team's dashboard service runs on its own pods, discovered and composed by a central hub.

Concepts

  • Text-to-SQL — the agent writes SQL from a plain-language request, grounded by MCP context.
  • Tenant isolation — per-team services isolated at the deployment/pod level; blast radius of a broken dashboard is one team.
  • LLM hallucination — the core risk framed as "a confident, beautiful, wrong number" with no error; the pipeline's execute-against-live-data check is the mitigation.
  • Serverless compute — cited as the ingredient that "could turn all of that into a running service in an afternoon."
  • Dashboards-as-code — every dashboard is a manifest + SQL + page stored in Git; changes flow through PRs and CI.
  • Trust in generated analytics — "a dashboard that's quietly wrong is worse than no dashboard at all, because someone will believe it."

Patterns

  • ci-gated-dashboard-publish — treat generated dashboards as code; gate every change (human or agent) on the same automated checks, including a live-query execution check, before it can go live.
  • per-team-independently-deployed-service-with-central-hub — each team ships its own independently deployed service; a central hub discovers and stitches them into one experience for deploy-time isolation.
  • ai-assembles-from-curated-component-library — constrain the LLM to pick from a small library of tested, branded, state-handling components rather than generating fragile markup.
  • natural-language-over-git-workflow — wrap the Git / CI / deploy machinery behind conversational English; publish opens a PR, safe dashboard changes auto-merge, platform changes stay human-gated.
  • patterns/default-on-security-upgrade — anything touching sensitive data must explicitly name who can see it or the change fails closed.

Operational numbers

  • >50 groups using Vizion; >2,000 views/day; ~1,000 monthly active users — spread organically with the author "doing almost nothing beyond getting out of the way."
  • ~30 tested, branded UI components in the shared library (KPI cards, data tables, filter bars, date pickers, sparklines, ~12 chart types incl. line, bar, funnel).
  • ~$500K/year legacy BI license cost eliminated (one license to build a dashboard, often another just to view one).
  • ~1 month of focused hardening by a dedicated team to take it from side project to company-wide platform.
  • Safe dashboard PRs deploy "live a few minutes later" after auto-approve/merge.

Caveats

  • Tier-3, first-person product narrative. The post is a personal story with no architecture diagrams and no low-level internals (no schema of the manifest, no CI-check implementation, no hub service-discovery mechanism disclosed). Architectural claims are described at the "what and why" altitude, not "how."
  • Vizion is Wix-internal and single-sourced. No dedicated system page created; treat operational numbers as self-reported.
  • "Serverless in an afternoon" refers to Wix's internal serverless substrate; the specific platform is unnamed.
  • Included under the Tier-3 borderline rule: the delivery-pipeline / service-isolation / federated-query architecture is a meaningful (~40–50%) share of the body, clearing the "≥20% architecture" bar for borderline product stories.

Source

Last updated · 766 distilled / 2,225 read