Architecture BlueprintEstablished

Hybrid SQL–Synapse Data Mesh Architecture

For organisations that need SQL Server for transactional workloads and Azure Synapse for analytics — with federated governance, data contracts, and a medallion pattern bridging both worlds.

Budhisamvad Research·Jan 2026·16 min read
2
distinct planes: transactional (SQL) and analytical (Synapse)
Architecture principle
#1
mistake: pointing analytics directly at the OLTP database
Budhisamvad analysis
3
medallion layers — bronze, silver, gold — bridge the two worlds
Lakehouse pattern
100%
of cross-plane data should flow through governed contracts
Budhisamvad standard

Most enterprises don't get to choose between transactional and analytical data platforms — they need both. SQL Server (or Azure SQL) handles the transactional workloads that run the business. Azure Synapse handles the analytical workloads that inform it. The architectural challenge is not picking one; it's connecting them in a way that gives analysts and data scientists access to transactional data without compromising the performance, consistency, or governance of the systems of record.

You don't choose between transactional and analytical platforms — you need both. The architecture is not about picking one; it's about connecting them so analysts reach transactional data without ever touching the systems of record.

The hybrid data platform principle
Watch out
The naive approach — pointing analytics tools directly at the transactional database — is how you turn a healthy OLTP system into a slow one. Analytical queries scan large ranges; transactional systems are optimised for small, fast operations. Run a quarter's worth of analytical aggregation against your production SQL Server and watch transaction latency spike. The planes must be separated.
Architecture — Hybrid transactional + analytical with medallion layers
Hybrid SQL Server and Azure Synapse data mesh with medallion architectureSQL ServerOLTP / TransactionalSystem of recordBronzeRaw ingestionSilverCleansed, conformedGoldBusiness-readySynapseAnalytics / OLAPData warehousePower BIDashboardsML / AIFeature storeData contracts govern each handoff · federated governance via Microsoft Purview across both planes

When to Use This Architecture

Use this when
  • You have established SQL Server / Azure SQL transactional systems you cannot replace
  • Analytics and ML workloads need access to transactional data at scale
  • Multiple domain teams need to own and serve their own data products
  • Regulatory requirements demand clear data lineage across both planes
Avoid when
  • Small data volumes where a single database serves both needs adequately
  • Greenfield builds where a unified lakehouse (Fabric, Databricks) is simpler
  • Organisations without the data governance maturity to manage data contracts
  • Cases where real-time analytics on transactional data is the core requirement

The Medallion Pattern as the Bridge

The medallion architecture (Bronze, Silver, Gold) is the bridge between the transactional and analytical planes. Bronze holds raw data ingested from the transactional systems — an immutable record of what arrived. Silver holds cleansed, conformed, de-duplicated data. Gold holds business-ready data products shaped for specific analytical consumption. Each layer is a deliberate transformation with a clear contract.

FrameworkThe Data Contract Principle™
Every handoff between planes is governed by an explicit data contract — a versioned agreement specifying schema, semantics, quality guarantees, and SLA. The transactional team commits to producing data matching the contract; the analytical team consumes against it. When the transactional schema changes, the contract makes the impact explicit instead of silently breaking downstream dashboards. Data contracts are what make a data mesh govern-able rather than a distributed mess.

Get the Hybrid Data Platform Architecture Guide

The SQL–Synapse medallion architecture diagram and data contract framework — for your data platform design review.

Federated Governance

A data mesh distributes data ownership to domain teams — but distributed ownership without federated governance produces chaos. The resolution is a federated computational governance model: central standards (security classifications, naming conventions, quality thresholds, lineage requirements) enforced automatically through tooling, with domain teams owning their data products within those standards. Microsoft Purview provides the catalogue, lineage, and classification layer that spans both the SQL Server and Synapse planes.

CriterionConcernCentralised (old)Federated mesh (this blueprint)
Data ownershipCentral data team owns everythingDomain teams own their data products
BottleneckCentral team becomes the bottleneckDomains move independently
GovernanceManual review, inconsistentAutomated standards, federated enforcement
QualityUnclear accountabilityDomain owns quality via data contracts
LineageOften missing or manualAutomated via Purview across both planes
Practitioner insight
From the field: A bank I advised tried to build a data mesh without data contracts. Each domain team produced data products, but with no versioned contracts governing the handoffs, every transactional schema change silently broke downstream analytics. Dashboards showed wrong numbers for days before anyone noticed. They re-introduced data contracts as mandatory, enforced in the pipeline, and the silent-breakage class of failures disappeared. The mesh only works when the contracts are real and enforced — not documented and ignored.

Implementation Sequence

  1. 01
    Establish the medallion layers in Synapse

    Create the Bronze, Silver, Gold structure. Bronze ingests raw from SQL Server via CDC or scheduled extracts. Define the transformation logic for each layer transition.

  2. 02
    Set up Change Data Capture from SQL Server

    Use SQL Server CDC or Azure Data Factory to move transactional changes into Bronze without running analytical load against the OLTP system. This is what protects transactional performance.

  3. 03
    Define data contracts for each domain

    For each data product a domain serves, write a versioned contract: schema, semantics, quality guarantees, SLA. Enforce schema validation in the pipeline so contract violations fail fast.

  4. 04
    Deploy Microsoft Purview for federated governance

    Catalogue both planes. Establish automated lineage tracking, data classification, and the central standards that domain teams operate within.

  5. 05
    Onboard domains incrementally

    Don't convert everything at once. Onboard one domain as a data product owner, prove the model, then expand. Each domain that adopts the contract model reduces central bottleneck load.

Found this useful? Share it →
This article is free to read. No paywall, no limits, ever.
✦ You just finished this article

There are 9 more like this. Plus AI advisors that go deeper.

Sign up free to get new research in your inbox, download frameworks as PDFs, and try the Data Platform Advisor — AI that personalises this guidance for your specific situation.

The Leadership Brief

Weekly practitioner intelligence — platform engineering, AI, cloud architecture. Every Monday. Free forever.

Downloadable frameworks

Platform Gravity Model™, IDP selection flowchart, AI Deployment Ladder — as one-pager PDFs for your team.

Early access to research

New reports and frameworks reach members before public release.

1 free AI Advisor question

Try a Reymentos AI Advisor on what you just read. No subscription needed to try.

P
S
A
M
R
Join technology leaders worldwide

Free forever · No credit card · Unsubscribe anytime · $39/mo for AI advisors