Data Mesh Architecture Complete Guide 2025: Domain-Driven Data, Data Products, Self-Service Platforms

[Order Domain] ──ETL──┐
[Payment Domain] ──ETL──┤
[Logistics Domain] ──ETL──┼──▶ [Central Data Team] ──▶ [Data Warehouse]
[Marketing Domain] ──ETL──┤        ↑ Bottleneck!
[Customer Domain] ──ETL──┘

[Order Domain Team] ──owns──▶ [Order Data Products]
[Payment Domain Team] ──owns──▶ [Payment Data Products]
[Logistics Domain Team] ──owns──▶ [Logistics Data Products]
[Marketing Domain Team] ──owns──▶ [Marketing Data Products]

         ↕ Self-Service Platform + Federated Governance ↕

# Domain ownership mapping example
domains:
  order:
    owner_team: "order-squad"
    data_products:
      - name: "orders-fact"
        description: "Order event-based fact table"
      - name: "order-items-dimension"
        description: "Order items dimension"
    responsibilities:
      - "Data quality assurance"
      - "SLA compliance"
      - "Schema change management"
      - "Consumer support"

  payment:
    owner_team: "payment-squad"
    data_products:
      - name: "transactions-fact"
        description: "Payment transactions fact table"
      - name: "payment-methods-dimension"
        description: "Payment methods dimension"

# Data product specification example (dataproduct.yaml)
apiVersion: datamesh/v1
kind: DataProduct
metadata:
  name: orders-fact
  domain: order
  owner: order-squad
  description: "Real-time order event-based fact data"

spec:
  # Discoverability
  tags: ["order", "ecommerce", "fact-table"]
  documentation:
    url: "https://data-catalog.internal/orders-fact"
    schema_doc: "https://schema-registry.internal/orders-fact/latest"

  # Addressability
  output_ports:
    - name: batch
      type: bigquery
      location: "project.dataset.orders_fact"
      format: parquet
    - name: streaming
      type: kafka
      location: "orders.fact.v2"
      format: avro
    - name: api
      type: rest
      location: "https://data-api.internal/orders-fact"

  # Trustworthiness
  sla:
    freshness: "5 minutes"
    availability: "99.9%"
    completeness: "99.5%"
  quality_checks:
    - type: "not_null"
      columns: ["order_id", "customer_id", "created_at"]
    - type: "unique"
      columns: ["order_id"]
    - type: "range"
      column: "total_amount"
      min: 0

  # Self-describing
  schema:
    format: avro
    registry: "https://schema-registry.internal"
    subject: "orders-fact-value"
    compatibility: BACKWARD

  # Interoperable
  global_standards:
    id_format: "UUID v4"
    timestamp_format: "ISO 8601 UTC"
    currency_format: "ISO 4217"

  # Secure
  access_control:
    classification: "confidential"
    pii_columns: ["customer_email", "shipping_address"]
    encryption: "AES-256"

┌─────────────────────────────────────────────────────────┐
│                Self-Service Data Platform                │
├─────────────────────────────────────────────────────────┤
│  [Data Product Builder]  [Pipeline Templates]  [Monitoring] │
│  [Schema Registry]       [Data Catalog]       [Access Mgmt] │
├─────────────────────────────────────────────────────────┤
│  [Infrastructure Abstraction Layer]                     │
│  - Kubernetes Operators                                 │
│  - Terraform Modules                                    │
│  - CI/CD Pipelines                                      │
├─────────────────────────────────────────────────────────┤
│  [Foundation Infrastructure]                            │
│  - Kafka / Flink / Spark                                │
│  - BigQuery / Snowflake / Databricks                    │
│  - Airflow / dbt                                        │
└─────────────────────────────────────────────────────────┘

platform_capabilities:
  data_product_lifecycle:
    - "Data product creation (scaffold/template)"
    - "Schema registration and version management"
    - "Build/test/deploy automation"
    - "Data quality monitoring"

  infrastructure:
    - "Storage provisioning (S3, GCS, BigQuery)"
    - "Streaming infrastructure (Kafka topics, Flink jobs)"
    - "Batch processing (Spark, dbt)"
    - "Orchestration (Airflow DAGs)"

  governance_automation:
    - "Access permission auto-provisioning"
    - "Data classification auto-tagging"
    - "SLA monitoring and alerting"
    - "Data lineage auto-tracking"

  developer_experience:
    - "CLI tools (datamesh-cli)"
    - "Web portal (data catalog)"
    - "SDK (Python, Java, Go)"
    - "Documentation auto-generation"

# Federated governance structure
governance_model = {
    "global_policies": {
        # Defined centrally - all domains must comply
        "interoperability": {
            "id_standard": "UUID v4",
            "timestamp_standard": "ISO 8601 UTC",
            "encoding": "UTF-8",
        },
        "security": {
            "pii_encryption": "required",
            "access_logging": "required",
            "data_classification": ["public", "internal", "confidential", "restricted"],
        },
        "quality": {
            "minimum_sla_availability": 0.99,
            "schema_compatibility": "BACKWARD",
            "documentation": "required",
        },
    },
    "domain_autonomy": {
        # Each domain decides autonomously
        "technology_choice": "Domain team selects appropriate technology",
        "internal_modeling": "Internal data modeling within domain",
        "release_cadence": "Data product release cadence",
        "team_structure": "Internal roles and processes within team",
    },
    "computational_enforcement": {
        # Automated policy verification as code
        "ci_cd_gates": "Automated policy compliance verification at build time",
        "runtime_monitoring": "Automated SLA monitoring in production",
        "automated_classification": "Automated PII detection and tagging",
    },
}

Data Fabric (Technology-centric approach)
==========================================
- Automated metadata management
- AI/ML-based data integration
- Centrally managed virtual data layer
- Knowledge Graph for data connectivity
- Maintains existing central team structure

Data Mesh (Organization-centric approach)
==========================================
- Domain-based distributed ownership
- Treat data as products
- Self-service platform
- Federated governance
- Requires organizational structure change

┌────────────────────────────────────────────────┐
│         Data Product Characteristics            │
├────────────────────────────────────────────────┤
│                                                │
│  1. Discoverable                               │
│     - Auto-registered in data catalog          │
│     - Meaningful metadata                      │
│                                                │
│  2. Addressable                                │
│     - Unique URI/ARN                           │
│     - Versioned endpoints                      │
│                                                │
│  3. Trustworthy                                │
│     - SLA guarantees                           │
│     - Published quality metrics                │
│                                                │
│  4. Self-describing                            │
│     - Schema + docs + sample data              │
│     - Semantic metadata                        │
│                                                │
│  5. Interoperable                              │
│     - Global standards compliance              │
│     - Standardized IDs/timestamps              │
│                                                │
│  6. Secure                                     │
│     - Fine-grained access control              │
│     - PII protection                           │
│                                                │
└────────────────────────────────────────────────┘

# Multiple Output Port example
class OrdersDataProduct:
    """Orders Data Product - Multiple Output Ports"""

    def __init__(self):
        self.domain = "order"
        self.name = "orders-fact"
        self.version = "2.1.0"

    # Batch Output Port (for analysts/data scientists)
    @output_port(type="batch")
    def bigquery_table(self):
        return {
            "location": "analytics.order_domain.orders_fact_v2",
            "format": "columnar",
            "partitioned_by": "order_date",
            "clustered_by": ["customer_id", "status"],
            "refresh": "hourly",
        }

    # Streaming Output Port (for real-time systems)
    @output_port(type="streaming")
    def kafka_topic(self):
        return {
            "location": "order.fact.v2",
            "format": "avro",
            "schema_registry": "https://schema-registry.internal",
            "partitioned_by": "customer_id",
            "retention": "7 days",
        }

    # API Output Port (for applications)
    @output_port(type="api")
    def rest_api(self):
        return {
            "base_url": "https://data-api.internal/v2/orders",
            "auth": "OAuth2",
            "rate_limit": "1000 req/min",
            "pagination": "cursor-based",
        }

    # File Output Port (for ML training)
    @output_port(type="file")
    def s3_export(self):
        return {
            "location": "s3://data-products/order/orders-fact/",
            "format": "parquet",
            "partitioned_by": ["year", "month", "day"],
            "snapshot": "daily",
        }

-- dbt model example: Orders fact table transformation
-- models/orders_fact.sql

WITH raw_orders AS (
    -- Input Port: Operational DB CDC stream
    SELECT * FROM {{ source('order_cdc', 'orders') }}
),

raw_items AS (
    SELECT * FROM {{ source('order_cdc', 'order_items') }}
),

enriched AS (
    SELECT
        o.order_id,
        o.customer_id,
        o.status,
        o.created_at,
        o.updated_at,
        COUNT(i.item_id) AS item_count,
        SUM(i.quantity * i.unit_price) AS subtotal,
        SUM(i.discount_amount) AS total_discount,
        SUM(i.quantity * i.unit_price) - SUM(i.discount_amount) AS total_amount,
        o.currency
    FROM raw_orders o
    LEFT JOIN raw_items i ON o.order_id = i.order_id
    GROUP BY o.order_id, o.customer_id, o.status,
             o.created_at, o.updated_at, o.currency
),

with_sla_metrics AS (
    SELECT
        *,
        -- Data quality metrics
        CASE
            WHEN order_id IS NOT NULL
                 AND customer_id IS NOT NULL
                 AND total_amount >= 0
            THEN TRUE ELSE FALSE
        END AS is_valid,
        CURRENT_TIMESTAMP() AS processed_at
    FROM enriched
)

SELECT * FROM with_sla_metrics

E-Commerce Business Domain Decomposition
============================================

┌─────────────────────────────────────────┐
│         Source-Aligned Domains           │
│                                         │
│  [Orders] ──▶ orders-fact               │
│               order-items-dim           │
│                                         │
│  [Payments] ──▶ transactions-fact       │
│                 refunds-fact            │
│                                         │
│  [Inventory] ──▶ inventory-snapshot     │
│                  stock-movements-fact   │
│                                         │
│  [Customers] ──▶ customer-profiles     │
│                  customer-events-fact   │
│                                         │
│  [Products] ──▶ product-catalog        │
│                 pricing-history         │
└────────────────┬────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────┐
│       Aggregate-Aligned Domains         │
│                                         │
│  [Customer 360] ──▶ unified-customer   │
│     (Customer + Orders + Payments)      │
│                                         │
│  [Product Intelligence] ──▶ product-360│
│     (Products + Inventory + Pricing)    │
└────────────────┬────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────┐
│       Consumer-Aligned Domains          │
│                                         │
│  [Marketing Analytics] ──▶ campaign-   │
│     performance, customer-segments     │
│                                         │
│  [Financial Reporting] ──▶ revenue-    │
│     report, cost-analysis              │
└─────────────────────────────────────────┘

domain_boundary_criteria:
  business_alignment:
    - "Does it align with organizational structure?"
    - "Can a single team own this scope?"
    - "Are business terms and context consistent?"

  data_characteristics:
    - "Is the data change frequency similar?"
    - "Does it come from the same source system?"
    - "Is the data queried together?"

  team_capacity:
    - "Does the team have capacity to maintain data products?"
    - "Are domain experts present on the team?"
    - "Is it manageable at a two-pizza team size?"

# Cookiecutter template: data-product-template
project_structure:
  - dataproduct.yaml       # Data product spec
  - schema/
    - v1.avsc              # Avro schema
  - transforms/
    - models/
      - staging/           # Staging models
      - marts/             # Mart models
    - dbt_project.yml
  - quality/
    - expectations.yaml    # Great Expectations config
  - tests/
    - test_transforms.py
    - test_quality.py
  - ci/
    - pipeline.yaml        # CI/CD pipeline
  - docs/
    - README.md
    - CHANGELOG.md

# Schema Registry usage example
from confluent_kafka.schema_registry import SchemaRegistryClient
from confluent_kafka.schema_registry.avro import AvroSerializer

schema_registry_config = {
    "url": "https://schema-registry.internal",
    "basic.auth.user.info": "api-key:api-secret",
}

client = SchemaRegistryClient(schema_registry_config)

# Schema registration
order_schema = """
{
    "type": "record",
    "name": "OrderFact",
    "namespace": "com.company.order",
    "fields": [
        {"name": "order_id", "type": "string", "doc": "Unique order ID (UUID v4)"},
        {"name": "customer_id", "type": "string"},
        {"name": "status", "type": {
            "type": "enum",
            "name": "OrderStatus",
            "symbols": ["CREATED", "CONFIRMED", "SHIPPED", "DELIVERED", "CANCELLED"]
        }},
        {"name": "total_amount", "type": {"type": "bytes", "logicalType": "decimal", "precision": 10, "scale": 2}},
        {"name": "currency", "type": "string", "doc": "ISO 4217 currency code"},
        {"name": "created_at", "type": {"type": "long", "logicalType": "timestamp-millis"}},
        {"name": "metadata", "type": ["null", {"type": "map", "values": "string"}], "default": null}
    ]
}
"""

# Compatibility verification (BACKWARD)
schema_id = client.register_schema(
    subject="orders-fact-value",
    schema=Schema(order_schema, schema_type="AVRO"),
)

# Data catalog registration using DataHub
from datahub.emitter.rest_emitter import DatahubRestEmitter
from datahub.metadata.schema_classes import (
    DatasetPropertiesClass,
    OwnershipClass,
    OwnerClass,
    OwnershipTypeClass,
)

emitter = DatahubRestEmitter("https://datahub.internal")

# Register data product metadata
dataset_properties = DatasetPropertiesClass(
    name="orders-fact",
    description="Real-time order event-based fact data product",
    customProperties={
        "domain": "order",
        "data_product_version": "2.1.0",
        "sla_freshness": "5 minutes",
        "sla_availability": "99.9%",
        "classification": "confidential",
    },
)

ownership = OwnershipClass(
    owners=[
        OwnerClass(
            owner="urn:li:corpGroup:order-squad",
            type=OwnershipTypeClass.DATAOWNER,
        )
    ]
)

# Lineage registration
lineage = UpstreamLineageClass(
    upstreams=[
        UpstreamClass(
            dataset="urn:li:dataset:(urn:li:dataPlatform:mysql,order_service.orders,PROD)",
            type=DatasetLineageTypeClass.TRANSFORMED,
        )
    ]
)

# Quality checks using Great Expectations
import great_expectations as gx

context = gx.get_context()

# Define data product quality expectations
validator = context.sources.pandas_default.read_dataframe(orders_df)

# Required column NULL checks
validator.expect_column_values_to_not_be_null("order_id")
validator.expect_column_values_to_not_be_null("customer_id")
validator.expect_column_values_to_not_be_null("created_at")

# Uniqueness checks
validator.expect_column_values_to_be_unique("order_id")

# Range checks
validator.expect_column_values_to_be_between(
    "total_amount", min_value=0, max_value=1000000
)

# Referential integrity
validator.expect_column_values_to_be_in_set(
    "status",
    ["CREATED", "CONFIRMED", "SHIPPED", "DELIVERED", "CANCELLED"]
)

# Freshness check
validator.expect_column_max_to_be_between(
    "created_at",
    min_value=datetime.now() - timedelta(minutes=10),
    max_value=datetime.now(),
)

results = validator.validate()
print(f"Quality Score: {results.statistics['success_percent']}%")

# data-contract.yaml
dataContractSpecification: "0.9.3"
id: "urn:datacontract:order:orders-fact"
info:
  title: "Orders Fact Data Contract"
  version: "2.1.0"
  owner: "order-squad"
  contact:
    name: "Order Squad"
    email: "order-squad@company.com"
    slack: "#order-data"

servers:
  production:
    type: BigQuery
    project: analytics-prod
    dataset: order_domain

terms:
  usage: "Internal analytics and reporting"
  limitations: "PII data must not be exported to external systems"
  billing: "Cost allocated to consumer team"

models:
  orders_fact:
    description: "Orders fact table"
    type: table
    fields:
      order_id:
        type: string
        required: true
        unique: true
        description: "Unique order identifier (UUID v4)"
      customer_id:
        type: string
        required: true
        pii: true
        classification: confidential
      status:
        type: string
        required: true
        enum: ["CREATED", "CONFIRMED", "SHIPPED", "DELIVERED", "CANCELLED"]
      total_amount:
        type: decimal
        required: true
        description: "Order total amount (after discounts)"
        quality:
          - type: range
            min: 0
      currency:
        type: string
        required: true
        pattern: "^[A-Z]{3}$"
      created_at:
        type: timestamp
        required: true

quality:
  type: SodaCL
  specification:
    checks for orders_fact:
      - row_count > 0
      - missing_count(order_id) = 0
      - duplicate_count(order_id) = 0
      - invalid_count(total_amount) = 0:
          valid min: 0
      - freshness(created_at) < 10m

servicelevels:
  availability:
    percentage: "99.9%"
  retention:
    period: "3 years"
    unlimited: false
  latency:
    threshold: "5 minutes"
    percentile: "p99"

# Governance automation using OPA (Open Policy Agent)
# policy/data_product_policy.rego

package datamesh.governance

# All data products must have an owner
deny[msg] {
    input.kind == "DataProduct"
    not input.metadata.owner
    msg := "Data product does not have an owner assigned"
}

# PII columns must have encryption configured
deny[msg] {
    input.kind == "DataProduct"
    field := input.spec.schema.fields[_]
    field.pii == true
    not field.encryption
    msg := sprintf("PII column '%s' does not have encryption configured", [field.name])
}

# SLA availability must be at least 99%
deny[msg] {
    input.kind == "DataProduct"
    availability := to_number(trim_suffix(input.spec.sla.availability, "%"))
    availability < 99.0
    msg := sprintf("SLA availability at %.1f%% is below minimum threshold (99%%)", [availability])
}

# Global identifier standard compliance
deny[msg] {
    input.kind == "DataProduct"
    input.spec.global_standards.id_format != "UUID v4"
    msg := "ID format does not match global standard (UUID v4)"
}

# Timestamps must be ISO 8601 UTC
deny[msg] {
    input.kind == "DataProduct"
    input.spec.global_standards.timestamp_format != "ISO 8601 UTC"
    msg := "Timestamp format does not match global standard (ISO 8601 UTC)"
}

# Policy verification in CI/CD
# .github/workflows/data-product-ci.yaml
name: Data Product CI

on:
  pull_request:
    paths:
      - 'data-products/**'

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Validate Data Product Spec
        run: |
          datamesh-cli validate dataproduct.yaml

      - name: Check Schema Compatibility
        run: |
          datamesh-cli schema check \
            --subject orders-fact-value \
            --schema schema/v2.avsc \
            --compatibility BACKWARD

      - name: Run OPA Policy Checks
        uses: open-policy-agent/opa-action@v2
        with:
          policy: policy/
          input: dataproduct.yaml

      - name: Run Data Quality Tests
        run: |
          datamesh-cli quality test \
            --expectations quality/expectations.yaml \
            --sample-data tests/fixtures/

      - name: Generate Documentation
        run: |
          datamesh-cli docs generate \
            --output docs/ \
            --format markdown

phase_1_assess:
  goals:
    - "Evaluate current data architecture"
    - "Determine Data Mesh suitability"
    - "Select pilot domain"

  activities:
    - name: "Data maturity assessment"
      description: "Evaluate current data infrastructure, governance, org capabilities"
    - name: "Domain mapping"
      description: "Map business domains and data ownership"
    - name: "Pilot domain selection"
      criteria:
        - "Domain with clear data ownership"
        - "Domain with existing data pipelines"
        - "Domain with an enthusiastic team"
    - name: "Success metrics definition"
      metrics:
        - "Data product deployment lead time"
        - "Data consumer satisfaction"
        - "Data quality score"

  deliverables:
    - "Data Mesh suitability report"
    - "Pilot domain selection document"
    - "MVP scope definition"

phase_2_platform:
  goals:
    - "Self-service platform MVP"
    - "Data product templates"
    - "Basic governance framework"

  platform_mvp:
    - "Data product scaffold CLI"
    - "Schema registry"
    - "Basic data catalog"
    - "CI/CD pipeline templates"
    - "Monitoring dashboard"

  governance_foundation:
    - "Global standards document (identifiers, timestamps, etc.)"
    - "Data classification taxonomy"
    - "Basic access control policies"

phase_3_pilot:
  goals:
    - "Deploy data products in 2-3 domains"
    - "Collect platform feedback"
    - "Validate processes"

  pilot_domains:
    domain_1:
      name: "Orders"
      data_products: ["orders-fact", "order-items-dim"]
      team_size: 6
    domain_2:
      name: "Customers"
      data_products: ["customer-profiles", "customer-events"]
      team_size: 5

  learning_goals:
    - "Self-service platform usability"
    - "Data product development workflow"
    - "Cross-domain data sharing patterns"
    - "Governance automation effectiveness"

phase_4_scale:
  goals:
    - "Enterprise-wide data product adoption"
    - "Advanced governance automation"
    - "Data marketplace"

  scaling_strategy:
    - "Domain champion program"
    - "Internal data product certification"
    - "Success story sharing"
    - "Training and mentoring"

phase_5_optimize:
  goals:
    - "Continuous improvement"
    - "Advanced capability introduction"
    - "Culture establishment"

  advanced_capabilities:
    - "AI/ML-based automatic data quality detection"
    - "Automated lineage tracking"
    - "Data product recommendation system"
    - "Cost optimization automation"

datamesh_manager:
  description: "Dedicated management platform for Data Mesh implementation"
  features:
    - "Data product catalog"
    - "Data contract management"
    - "Domain map visualization"
    - "Governance policy management"
  integration:
    - "DataHub"
    - "dbt"
    - "Great Expectations"
    - "Apache Kafka"

# Using DataHub as data catalog
# docker-compose.yaml example (simplified)
services_config = """
services:
  datahub-gms:
    image: linkedin/datahub-gms:latest
    ports:
      - "8080:8080"
    environment:
      - EBEAN_DATASOURCE_URL=jdbc:mysql://mysql:3306/datahub
      - KAFKA_BOOTSTRAP_SERVER=broker:29092

  datahub-frontend:
    image: linkedin/datahub-frontend-react:latest
    ports:
      - "9002:9002"

  datahub-actions:
    image: linkedin/datahub-actions:latest
"""

-- Managing data products with Unity Catalog
-- Catalog = Domain
CREATE CATALOG IF NOT EXISTS order_domain;
CREATE SCHEMA IF NOT EXISTS order_domain.data_products;

-- Data product table
CREATE TABLE order_domain.data_products.orders_fact (
    order_id STRING NOT NULL COMMENT 'Unique order ID (UUID v4)',
    customer_id STRING NOT NULL COMMENT 'Customer ID',
    status STRING NOT NULL COMMENT 'Order status',
    total_amount DECIMAL(10, 2) NOT NULL COMMENT 'Order total amount',
    currency STRING NOT NULL COMMENT 'ISO 4217 currency code',
    created_at TIMESTAMP NOT NULL COMMENT 'Order creation time',
    processed_at TIMESTAMP COMMENT 'Data processing time'
)
USING DELTA
PARTITIONED BY (date_trunc('day', created_at))
COMMENT 'Real-time order event-based fact data product'
TBLPROPERTIES (
    'data_product.domain' = 'order',
    'data_product.owner' = 'order-squad',
    'data_product.version' = '2.1.0',
    'data_product.sla.freshness' = '5 minutes',
    'data_product.sla.availability' = '99.9%'
);

-- Access permission management
GRANT SELECT ON TABLE order_domain.data_products.orders_fact
TO `marketing-analytics-team`;

GRANT SELECT ON TABLE order_domain.data_products.orders_fact
TO `finance-reporting-team`;

┌─────────────────────────────────────────────┐
│          Data Mesh Team Topology             │
├─────────────────────────────────────────────┤
│                                             │
│  [Platform Team]                            │
│    - Build/operate self-service platform    │
│    - Infrastructure abstraction             │
│    - Provide tools and templates            │
│    - Enabling Team role                     │
│                                             │
│  [Domain Teams (Stream-aligned)]            │
│    - Own and operate data products          │
│    - Business domain expertise              │
│    - Each team includes Data Product Owner  │
│                                             │
│  [Governance Team (Enabling)]               │
│    - Define global standards                │
│    - Develop policy automation tools        │
│    - Support and train domain teams         │
│                                             │
│  [Data Product Owner Community]             │
│    - Cross-domain coordination              │
│    - Best practice sharing                  │
│    - Standards evolution                    │
│                                             │
└─────────────────────────────────────────────┘

data_product_owner:
  description: "Role managing the full lifecycle of data products"

  responsibilities:
    strategic:
      - "Data product roadmap management"
      - "Consumer requirements discovery"
      - "Data product value measurement"
    operational:
      - "SLA definition and monitoring"
      - "Data quality management"
      - "Consumer support"
    governance:
      - "Data contract management"
      - "Access permission approval"
      - "Global standards compliance"

  skills:
    - "Domain business knowledge"
    - "Data modeling"
    - "Product management"
    - "Basic data engineering"

  collaboration:
    with_platform_team: "Relay platform feature requirements"
    with_consumers: "Support data product usage"
    with_governance: "Provide policy feedback and improvement suggestions"

anti_patterns:
  - name: "Data Mesh in name only"
    description: "Distributing technology without organizational change"
    symptom: "Central data team still controls everything"
    fix: "Grant genuine ownership to domain teams, separate platform team"

  - name: "Distribution without governance"
    description: "Each domain proceeds independently without standards"
    symptom: "Data silos increase, interoperability degrades"
    fix: "Establish federated governance committee, define global standards"

  - name: "Distribution without platform"
    description: "Assigning responsibility to teams without a self-service platform"
    symptom: "Each team wastes time on infrastructure, duplicate investment"
    fix: "Form platform team first and provide MVP platform"

  - name: "Everything as a data product"
    description: "Making even internal temporary data into data products"
    symptom: "Excessive overhead, team fatigue"
    fix: "Only productize data with external consumption value"

  - name: "Big bang transformation"
    description: "Attempting enterprise-wide Data Mesh transformation at once"
    symptom: "Change resistance, confusion, failure"
    fix: "Start with pilot and gradually expand"

zalando_case:
  background:
    - "Europe's largest online fashion platform"
    - "49M+ customers, thousands of brands"
    - "200+ data sources"

  challenges_before:
    - "Central data team as bottleneck"
    - "Data request backlog of several months"
    - "Domain knowledge loss"

  implementation:
    - "Transitioned to domain-based data ownership"
    - "Self-service data infrastructure (Data Tooling)"
    - "Defined data product standards"
    - "Federated governance committee"

  results:
    - "Data product deployment time: weeks to days"
    - "Improved data quality"
    - "Increased domain team autonomy"

netflix_case:
  background:
    - "Global streaming service"
    - "200M+ subscribers"
    - "Vast A/B testing data"

  approach:
    - "Started with centralized data platform"
    - "Gradually transitioned to domain ownership"
    - "Robust self-service platform (Metacat, Dataflow)"
    - "Data quality automation"

  key_tools:
    - "Metacat: Unified metadata management"
    - "Dataflow: Data pipeline orchestration"
    - "Dataframe: Automated data quality validation"

intuit_case:
  background:
    - "TurboTax, QuickBooks, Mint financial software"
    - "100M+ customers"
    - "High data regulatory requirements"

  approach:
    - "Data Mesh + AI Platform integration"
    - "Domain-specific data asset definitions"
    - "Automated compliance verification"
    - "Internal data marketplace"

  results:
    - "Data scientist productivity improved 3x"
    - "Automated regulatory compliance"
    - "Increased cross-domain data utilization"