dotto.

Change has outgrown human review.

Microservices + events turn "small" schema edits into invisible blast radius.

"We should have known this would break."

See how it catches breakage

Why Teams Keep Getting Surprised

Dotto's bet is simple: Engineering systems are getting too complex for humans to reason about change impact manually.

This isn't regulatory. It's structural.

It shows up as teams adopt:

• Microservices
• Event-driven systems
• Platform teams owning shared contracts
• Faster release cycles
• Fewer humans per service

“We should have known this would break.”

Not because teams are careless — but because the blast radius was invisible at the time of change.

Before teams reach this point, they cope by:

• Fixing forward
• Rolling back
• Adding more process
• Writing longer PR descriptions

This works — until it doesn't.

Even worse: types can lie.

Types can remain “compatible” while meaning changes. A field stays optional, but downstream logic now expects it. A string enum gains a value no consumer handles. Failures don't show up until runtime.

This is semantic drift — and it's invisible to compilers, linters, and code review.

In high-risk domains, drift isn't just a bug.

Payments. Fintech integrations. Billing systems. Subtle contract or parameter changes can cause incorrect charges, failed refunds, reconciliation mismatches, or downstream inconsistencies.

Drift becomes operational and financial risk.

Dotto exists for teams that have crossed this line —where impact must be computed, not remembered.

See It In Action

Real CLI output showing Dotto's powerful detection capabilities.

~/your-project

$ dotto crawl --diff
Scanning 847 files...
Found 12 changed schemas

Breaking changes detected:
  - UserDTO: email field type changed (string -> string | null)
  + 11 more schema changes (no breaking)

Downstream impact:
  - AuthService (direct dependency)
  - NotificationService (2 hops)
  - BillingService (2 hops)

Exit code: 1 (breaking changes found)

Full Visibility Into Every Schema Change

From automatic discovery to CI enforcement, Dotto gives you complete control over your schema evolution.

Automatic Scanning

Crawls TypeScript DTOs, interfaces, and OpenAPI specs. No manual tagging required.

Breaking Change Detection

Detects type changes, new required fields, removed enum values - anything that could break consumers.

Impact Analysis

BFS traversal shows exactly which services are affected, with confidence scores.

Intent Drift Detection (Advanced)

Detects semantic changes when behavior shifts without type changes (e.g. nullable defaults, meaning changes, config-driven logic).

Interactive Graph

Auto-generated visualization. Click any node to see dependencies and downstream impact.

CI/CD Integration

GitHub Actions workflow blocks PRs with breaking changes. Exit code 1 = breaking.

Works Where You Work

Integrate Dotto into your existing CI/CD pipeline in minutes.

GitHub Actions

Available

GitLab CI

Coming Soon

Pre-commit Hooks

Available

Slack

Coming Soon

.github/workflows/schema-check.yml

name: Schema Check

on: [pull_request]

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

      - name: Schema Check
        run: |
          npx @natalietdg/dotto crawl --diff
          npx @natalietdg/dotto check
        # Fails PR if breaking changes detected

From Chaos to Clarity in 4 Steps

Initialize

dotto init

Creates your dependency graph

Crawl

dotto crawl

Scans TypeScript and OpenAPI files, extracts schemas and relationships

Check

dotto check

Compares against baseline, detects breaking changes

Ship

git merge

Non-breaking changes merge; breaking changes require explicit approval

Optional

Optional Proof Backends

When systems outgrow human review, change itself must become provable. Dotto supports multiple proof backends for teams that need stronger guarantees.

None

Development, small teams

Local only

Coming Soon

Git

Most teams

Signed commits

Tamper-evident

Hedera

Non-repudiation requirements

Blockchain consensus

Coming Soon

Sigstore

Open source, supply chain

Cryptographic signing

Why Hedera?

Most teams start with Git-based records. For teams that want non-repudiation, Hedera anchors every schema change to a public consensus layer — creating timestamped proof that can't be altered or disputed. Currently the only fully functional proof backend in Dotto.

Built for Teams

Stop breaking production. Start shipping with confidence.

Full Impact Analysis

See all downstream effects

Change Attribution

See which changes introduced breaking risk

CI/CD Ready

Exit code 1 on breaking

Blame-Free Reviews

Focus on impact, not guesswork

Optional Change Proof

Tamper-evident records for teams that want stronger guarantees.

Blockchain Anchoring

Hedera HCS integration

Intent Capture

Why every change was made

SHA-256 Verification

Tamper-proof certificates

Git Integration

Full commit history

Up and Running in 60 Seconds

Installation

Install globally

npm install -g @natalietdg/dotto

Or use npx (no install required)

npx @natalietdg/dotto --help

Quick Start

# 1. Navigate to your project
cd your-project

# 2. Initialize Dotto
dotto init

# 3. Build the dependency graph
dotto crawl

# 4. View the interactive graph
dotto graph
open graph.html

# 5. Check for breaking changes
dotto scan --base origin/main

# 6. Analyze impact of a schema
dotto impact UserDTO

What Gets Scanned

Automatically detects:
├── **/*.dto.ts          # TypeScript DTOs
├── **/*.schema.ts       # Schema files
├── **/*.interface.ts    # Interface definitions
├── **/*.openapi.json    # OpenAPI specs
├── **/*.openapi.yaml
├── **/*.swagger.json    # Swagger specs
└── **/*.swagger.yml

CLI Commands Reference

Command	Description
`dotto init`	Initialize Dotto in current directory
`dotto crawl`	Scan codebase and build dependency graph
`dotto crawl --diff`	Incremental scan (changed files only)
`dotto scan --base <commit>`	Git-aware change detection
`dotto impact <node-id>`	Analyze downstream impact
`dotto why <node-id>`	Show provenance chain
`dotto check`	Run compatibility checks
`dotto graph`	Generate HTML visualization
`dotto anchor`	Anchor to Hedera blockchain
`dotto verify <tx-id>`	Verify proof on Hedera