Summary
Vision. Current governance is mostly documentary. Extending Data Contract as Code, Executable Data Design (EDD) transforms data contracts into executable artefacts: design describes, validates and drives quality through code.
Why now. Generative AI convergence, regulatory pressure, Data Mesh and sovereignty: governance must be executed, not only written.
How. A declarative language readable by business experts and interpretable by systems (contracts, rules, mappings). A data quality gateway upstream of ingestion, auditable reports, and transformations validated by contracts (contract-to-contract mapping).
Applicability. Data migration, legacy recurring flows, continuous validation, compliance audits: EDD covers the full spectrum of structured governance needs.
Impact. Validated data, measurable quality, demonstrable compliance, reduced time-to-value.
Context: four converging forces
The data industry is undergoing a profound transformation. Four macro-trends are converging simultaneously, creating an urgent need for a new approach to data governance.
1. The explosion of generative AI
AI models now sit at the heart of business processes. Their reliability depends directly on the quality of their training data. The principle “garbage in, garbage out” is no longer a technical joke but a strategic business risk.
2. Regulatory pressure
The European AI Act (2025), reinforced GDPR, and sector-specific regulations (Basel III, Solvency II) require exhaustive data traceability. Organizations must prove the compliance of their data—not merely document it.
3. The emergence of Data Mesh
Data becomes a distributed product, managed by autonomous teams. This decentralization requires clear, executable “data contracts,” similar to API contracts in microservice architectures.
4. Digital sovereignty
European organizations seek to regain control of their data infrastructures. Demand for on-premise, sovereign and efficient solutions has never been stronger.
The core issue
These four forces expose a structural flaw: data governance remains documentary when it should be executable. Data contracts are written in Word documents, Confluence wikis, or unreadable JSON Schema specifications. They describe what data should be, but do not guarantee what they are.
The current approach and its limitations
Most organizations approach data quality reactively:
Traditional approach
- Document-based specifications
- Post-ingestion validation
- Fragmented unit tests
Observed outcomes
- Gap between specs and reality
- Late anomaly detection
- Exponential remediation costs
Existing tools — heavy ETL platforms or validation libraries — treat quality as an a posteriori control. They check, but do not guarantee. They document, but do not execute.
Executable Data Design: An executable approach to data governance
Executable Data Design (EDD) proposes a fundamental shift in how data is governed.
Specifications are no longer theoretical documentation but actual executable code.
Every field carries explicit business meaning encoded in its structure. Business meaning is no longer separate from technical structure: it becomes part of the design.
Validation does not simply say “valid” or “invalid.” It produces exhaustive metrics: error rates, completeness, value distributions. Quality becomes manageable.
Mappings between data models are no longer fragile imperative code. They are declarative, governed by stable business codes, and automatically verifiable.
Governance rules are no longer documentary policies. They apply in real time, during ingestion, before invalid data reaches critical systems.
Okyline: the embodiment of Executable Data Design
A declarative language by example
Okyline allows defining contracts from examples enriched with constraints. A field and its rules are described in a single line readable by business experts — and executable by the system. This removes the gap between specification and implementation: business teams understand the contract, IT teams execute it.
Measurable and preventive validation
Each process produces a detailed statistical report (validity, completeness, consistency) and the list of errors, usable by data stewards and auditors. The data quality gateway validates data before entering critical systems: compliant records pass, non-compliant ones are isolated for remediation. Each field carries a criticality level, making governance directly executable.
Contract-to-contract transformations
Declarative mapping links fields via stable business codes rather than fragile technical paths. Transformations become traceable, versionable and auditable, independent of structural changes.
Okyline Studio
Okyline Studio is a desktop web environment, without backend, providing interactive design on real data (JSON, XML, CSV, fixed-width formats).
The “edit → test → fix” loop runs in real time thanks to a serverless architecture: validation is carried out entirely in the browser. No network latency, no waiting: every schema modification immediately reflects on the example data, with instant visual feedback.
This reactivity turns contract design into a smooth, collaborative experience where business and IT teams refine rules directly on real cases, without friction.
Technical note: the Studio relies on the same Java engine as the CLI, transpiled via TeaVM for direct execution in the browser. This shared engine ensures total consistency between interactive validation and production execution.
Okyline CLI
Compact and autonomous, Okyline CLI integrates easily into existing pipelines: standalone Jar (< 1 MB) with no dependencies, multi-format parsing (JSON, JSONL, XML, legacy CSV/fixed-width multilines), quality filtering, local reports — everything runs locally without network access or external databases.
Technical note: integration with other products is performed through
standard Unix streams (stdin/stdout/stderr),
enabling Okyline to be orchestrated inside existing pipelines (Kafka, Airflow, S3, ETL)
without proprietary connectors. The fully autonomous, stateless JAR integrates natively into
your on-premise chains and any cloud environment (K8s, Lambda, Spark) without adaptation.
Lightweight and sovereign architecture
Desktop Studio, standalone CLI, embeddable library: data remains on-prem. With the ability to validate tens of thousands of objects per second on standard hardware, deployment is extremely fast and requires no dedicated infrastructure.
Impact and perspectives
A new framework for data contracts
Executable contracts reconcile business design, technical validation and operational governance — a shared language for interoperability.
Compliance by design
Exhaustive reports, traceability and automated auditing: compliance becomes a natural by-product of execution.
A foundation for responsible AI
EDD secures the quality of structured data in feature, training and inference pipelines: fewer biases, fewer propagation errors.
Data Mesh accelerator
In a federated model, clear and executable contracts allow domains to publish and consume with confidence.
The right moment
The convergence of AI, regulation, Data Mesh and sovereignty opens a window for adoption. Organizations are looking for an executable approach, not yet another validation tool. EDD meets this need — Okyline embodies it.
Conclusion
We have reached an inflection point: documentary approaches have hit their limits. EDD unifies design, execution and governance. Contracts become truly executable code; quality is measured; governance is executed.
Okyline demonstrates that the vision is operational, performant and ready for adoption today.