Skip to content

AI-native data architecture

Your data architecture, connected — from intent to production.

DataArkh connects models, data flows, lineage, governance, impact analysis, and production changes into one continuously evolving architecture graph.

Explore the platform Request a demo

Already have access? Sign in. New to DataArkh? Explore the platform or request a demo.

Model
Conceptual → Logical → Physical
Architecture
Model → Flow → Lineage → Impact
Change
Intent → Diff → Review → Migration
DataArkh / Architecture Product preview

Illustrative architecture

  1. Customer → Orders → Payments
  2. ↓
  3. Silver → Gold → BI
  • RenameColumn customer.email_addr → email
Impact
3 models
Flows
2 flows
Changeset
Ready for review

An illustrative scenario — architecture, impact and a semantic rename, not a live session.

The problem

Your architecture is real. The record of it is scattered.

Architecture is distributed across modeling tools, transformation code, catalogs, repositories and migration systems. The cost is not inconvenience — it is that a change is hard to understand before it ships.

  1. 01

    Modeling

    Modelling tools

    Entities, keys and relationships, usually in a file a pull request cannot review as structure.

  2. 02

    Pipelines

    Transformation code

    The shape data actually takes, decided in SQL far from the model.

  3. 03

    Catalogs

    Lineage after the fact

    Meaning reconstructed from what already shipped, not from what was designed.

  4. 04

    Migrations

    Change scripts

    A hand-written script, reviewed as text, hoping it matches the architecture.

DataArkh does not replace those tools. It connects those perspectives around one architecture graph, in your Git repository, so a change to a column and the migration that ships it are the same object at different stages of review.

Platform

One architecture. Every perspective.

Six views over the same model, so design, movement, meaning and change never drift apart into separate tools.

Model

How data is structured.

Entities, keys and relationships across conceptual, logical and physical tiers.

Data flow

How data moves, transforms and becomes useful.

Source through bronze, silver and gold to consumption — layering, not a second architecture.

01

Model

Design across conceptual, logical and physical tiers, with the mapping between them held as data rather than convention.

Conceptual Logical Physical
02

Data flow

Declare how data moves from landing to consumption. Layers are architectural concepts, not separate ownership boundaries.

Source Bronze Silver Gold Consumption
03

Lineage

Trace a column back through the transforms that produced it, at column and object grain.

orders.total fx_convert revenue.amount
04

Impact

Before a change ships, see which models import the object, which exports promise it, and which consumers read it.

  • 1 column changed
  • importing models
  • exports and consumers
05

Govern

House standards compile to rules the validator runs on every change, so a policy is something that fails a build rather than a page in Confluence.

  • missing-primary-key
  • identifier-too-long
  • undeclared-property
06

Change

Group edits into a changeset, open it as a pull request, and render the migration your team already uses.

Changeset Review Merge Migration

Architecture graph

Your architecture becomes a living graph.

The same objects appear as a model, a flow, a lineage path or an impact set. Switching the lens does not change the architecture — it changes what you are asking of it.

Entities and the keys that join them.

  1. Customer
  2. Orders
  3. Silver
  4. Gold
  5. BI
  • model Entity relationship
  • flow Data movement
  • lineage Transformation dependency
  • impact Change dependency

How it works

From intent to production, and back again.

The changeset you review is the changeset that renders the migration, and what production reports back becomes the next thing you model.

  1. 01

    Model

    Design entities, keys and relationships across the three tiers.

  2. 02

    Draft

    Edits stage as a draft so work in progress never reaches main.

  3. 03

    Changeset

    The diff resolves to semantic operations — a rename stays a rename.

  4. 04

    Review

    Open it as a change request, with reviewers and approvals.

  5. 05

    Merge

    A branch and pull request in your repository, rebased before merge.

  6. 06

    Migration

    Render to SQL, Liquibase, Flyway, Alembic or Prisma.

  7. 07

    Drift

    Compare production back against the model and report what moved.

  8. Back to Model

    What drifted in production is the next thing to model. The lifecycle closes.

Intelligence

Reason against the architecture, not an isolated prompt.

The useful question is never “what should a table look like?” It is “what should change, given this model, these imports, these rules.” That is the layer we are building.

architecture analysis Product concept

User intent

We need to support multi-currency orders. What should change?

DataArkh context

  • Orders · Payments · Customer
  • imports from retail-core
  • rule missing-primary-key

Proposed change

  • AddColumn · order.currency_code · char(3)
  • AddColumn · payment.currency_code · char(3)

Then

Impact → changeset → review → migration

Example · 2 importing models · 1 export · 1 consumer

This is a walkthrough of the shape, not a live model. Suggestions in the product today are deterministic. An architect that reasons over the graph with an LLM is the next layer, not a claim we are making yet.

Governance

Govern architecture before it reaches production.

House standards compile to rules the validator runs on every change. A policy is something that fails a build, not a page in Confluence.

Example evaluation

Change
AddForeignKey · order.customer_id → customer.id
Rule
relationship-key-type
Result
BLOCK

The ends of the key do not share a type, so the join could never hold. Naming, keys, user-defined properties, layering and glossary bindings are all rules the product already runs. Ownership is a property you declare; a missing required property is an error, not a reminder.

  • missing-primary-key warn
  • identifier-too-long block
  • undeclared-property block
  • relationship-key-type block
  • unmapped-logical-entity warn
  • layer-allows-archetype warn

Change

Change the architecture, not just the database.

A rename is stored as a rename. Impact, governance, review and migration are readings of the same changeset — not a later reconstruction from SQL.

changeset / retail-core Illustrative
  • RenameColumn customer.email_addr → email
  • AlterColumnType order.total numeric(10,2) → numeric(18,2)
  • AddColumn order.currency char(3) not null
  • AddForeignKey order.customer_id → customer.id
Why
Rename a column without losing its identity
Impact
Example · importing models, flows, one export
Governance
Declared rules evaluated before merge
Review
Ready for review as a pull request
Migration
SQL · Liquibase · Flyway · Alembic · Prisma

Integrations

Designed for the stack you already have.

The model of record is Git. The projection is Postgres. Migrations render into the tools your pipelines already run. Nothing here is a claimed connector we have not shipped.

Platforms

  • PostgreSQL Supported
  • Snowflake Supported

Migrations

  • SQL Supported
  • Liquibase Supported
  • Flyway Supported
  • Alembic Supported
  • Prisma Supported

Version control

  • GitHub Supported

Lineage import

  • dbt manifest Supported
  • OpenLineage Supported

PostgreSQL and Snowflake are modelling and migration dialects. Live reverse-engineering of a Snowflake warehouse is not claimed yet. Other warehouses, GitLab and directory sync are not listed because they are not in the product yet.

Who it is for

Built for the people who shape data architecture.

Four jobs, one model. Nobody has to export a diagram to explain a change to somebody else.

Built for enterprise data environments

  • Git-native

    The model of record lives in your repository.

  • Role-aware

    Viewer, modeler, steward, release manager and admin are separate permissions.

  • Auditable

    Tenant-scoped actions are written to an append-only event log.

  • Isolated

    Every projection table has row-level security enabled and forced.

Certifications, SAML and SCIM are not claimed. See Security.

Build an architecture you can change with confidence.

Connect models, flows, lineage, governance and production change around one architecture graph.

Explore the platform Request a demo

Already have access? Sign in. New to DataArkh? Explore the platform or request a demo.