Skip to main content

​
Overview

The data-mesh-contract command generates comprehensive data product contracts that follow data mesh architectural principles. It creates standardized contract definitions including schema specifications, data quality rules, service level objectives (SLOs), access policies, and governance metadata. This command helps organizations implement data mesh practices by treating data as a product with clear contracts, ownership, and quality guarantees.

​
Usage

arckit data-mesh-contract [options]

​
Key Features

  • Data Product Definition: Complete data product metadata including domain, ownership, and lifecycle
  • Schema Specifications: Detailed field definitions with types, constraints, and business meaning
  • Quality Contracts: Data quality rules, validation logic, and acceptance criteria
  • SLO Definitions: Service level objectives for availability, freshness, completeness, and accuracy
  • Access Policies: Consumer access patterns, authentication, and authorization requirements
  • Governance Metadata: Classification, lineage, retention policies, and compliance tags
  • Versioning Strategy: Semantic versioning with backward compatibility guarantees
  • Integration Patterns: API specifications, event schemas, and batch transfer formats

​
Arguments

​
Optional Arguments

  • --domain <name>: Data domain name (e.g., “customer”, “order”, “product”)
  • --product <name>: Data product name within the domain
  • --version <semver>: Contract version (semantic versioning: MAJOR.MINOR.PATCH)
  • --format <type>: Output format - json, yaml, or markdown (default: yaml)
  • --template <path>: Custom contract template file path
  • --strict: Enable strict validation mode with enhanced quality checks
  • --output <path>: Custom output file path (default: data-mesh/contracts/<domain>-<product>-contract.yaml)

​
Output

Generates a comprehensive data mesh contract file containing:

​
Contract Structure

  1. Product Metadata
    • Data product identifier and version
    • Domain and subdomain classification
    • Owner team and contact information
    • Lifecycle stage (development, production, deprecated)
  2. Schema Definition
    • Field names, types, and formats
    • Required vs optional fields
    • Business definitions and semantics
    • Constraints and validation rules
  3. Quality Contract
    • Completeness thresholds
    • Accuracy requirements
    • Consistency rules
    • Timeliness guarantees
  4. Service Level Objectives
    • Availability targets (e.g., 99.9% uptime)
    • Freshness SLOs (e.g., data latency < 15 minutes)
    • Completeness SLOs (e.g., >95% fields populated)
    • Response time guarantees
  5. Access & Integration
    • Consumer interface specifications (REST API, events, batch)
    • Authentication and authorization requirements
    • Rate limits and quotas
    • Sample queries and usage examples
  6. Governance
    • Data classification level (public, internal, confidential, restricted)
    • Retention and archival policies
    • Lineage and dependencies
    • Compliance tags (GDPR, HIPAA, etc.)

​
Example Output Location

data-mesh/
├── contracts/
│   ├── customer-profile-contract.yaml
│   ├── order-transactions-contract.yaml
│   └── product-catalog-contract.yaml
└── schemas/
    └── [generated schema files]

​
Examples

​
Generate Basic Contract

arckit data-mesh-contract --domain customer --product profile
Creates a customer profile data product contract with standard template.

​
Generate Contract with Version

arckit data-mesh-contract --domain order --product transactions --version 2.1.0
Generates version 2.1.0 of the order transactions contract.

​
Generate JSON Format Contract

arckit data-mesh-contract --domain product --product catalog --format json
Outputs the contract in JSON format instead of YAML.

​
Generate with Custom Template

arckit data-mesh-contract --domain analytics --product metrics --template ./templates/custom-contract.yaml
Uses a custom contract template for specialized requirements.

​
Generate with Strict Validation

arckit data-mesh-contract --domain financial --product transactions --strict
Enables strict validation mode with enhanced quality checks for sensitive data.

​
Prerequisites

​
Required Artifacts

While the command can generate a baseline contract from templates, it works best when these artifacts exist:
  • Domain Model (domain-model.yaml): Defines domain boundaries and data products
  • Data Dictionary (data-dictionary.yaml): Field definitions and business glossary
  • Architecture Decision Records: Decisions about data mesh implementation
  1. Define your data domains and products
  2. Establish ownership and team structures
  3. Set organizational SLO standards
  4. Define classification and governance policies

​
Data Mesh Principles

The generated contracts embody the four principles of data mesh:
  1. Domain Ownership: Clear domain and owner identification
  2. Data as a Product: Treating data with product thinking (usability, quality, SLOs)
  3. Self-serve Platform: Standard contract format enables automated provisioning
  4. Federated Computational Governance: Embedded governance metadata and policies

​
Contract Elements

​
Schema Types Supported

  • Structured data (relational, columnar)
  • Semi-structured data (JSON, XML)
  • Event streams (Kafka, Kinesis)
  • Document stores (MongoDB, DynamoDB)
  • Time-series data

​
SLO Categories

  • Availability: Uptime and accessibility guarantees
  • Freshness: Data latency and update frequency
  • Completeness: Required field population rates
  • Accuracy: Validation pass rates and error thresholds
  • Consistency: Cross-system reconciliation requirements

​
Access Patterns

  • Synchronous: REST APIs, GraphQL
  • Asynchronous: Event streams, message queues
  • Batch: File transfers, bulk exports
  • Query: SQL interfaces, search APIs

​
Integration with Other Commands

​
Quality Assurance

# Generate contract
arckit data-mesh-contract --domain customer --product profile

# Validate data against contract
arckit analyze --check-quality

​
Traceability

# Link contract to requirements
arckit traceability --include-data-contracts

​
Documentation

# Generate data product documentation
arckit pages --include-contracts

​
Best Practices

  1. Version Semantically: Use semantic versioning (MAJOR.MINOR.PATCH)
    • MAJOR: Breaking schema changes
    • MINOR: Backward-compatible additions
    • PATCH: Documentation or metadata updates
  2. Define Realistic SLOs: Base SLOs on actual capabilities and monitoring
  3. Document Business Context: Include clear business definitions for all fields
  4. Specify Access Patterns: Clearly define how consumers should access data
  5. Include Examples: Provide sample queries and usage patterns
  6. Review Regularly: Treat contracts as living documents that evolve
  7. Automate Validation: Integrate contract validation into CI/CD pipelines

​
Contract Validation

The command validates contracts against:
  • Schema completeness and consistency
  • SLO measurability and realism
  • Governance policy compliance
  • Versioning standards
  • Access pattern specifications
  • analyze - Validate data quality against contract SLOs
  • traceability - Link contracts to requirements and systems
  • pages - Generate data product catalog documentation
  • template-builder - Create custom contract templates

​
Resources

​
Output Summary

The command displays: 
Data Mesh Contract Generated
============================
Domain: customer
Product: profile
Version: 1.0.0
Contract: data-mesh/contracts/customer-profile-contract.yaml

Contract Summary:
- 24 schema fields defined
- 4 SLOs specified (availability, freshness, completeness, accuracy)
- 2 access patterns (REST API, Events)
- Classification: Internal
- Owner: customer-domain-team

Next Steps:
1. Review and validate contract with stakeholders
2. Implement data quality monitoring for SLOs
3. Publish contract to data catalog
4. Enable consumer access provisioning
Only the summary is shown - the full contract is written to the specified output file.

Build docs developers (and LLMs) love

Get started for freeTalk to us