dotto.

Stop Breaking Changes From Breaking Production

Dotto is code compliance infrastructure for TypeScript microservices.

Companies lose millions when schema changes break production with no audit trail.

Dotto detects drift, maps impact, and provides immutable proof for regulators.

View Demo Read Docs

Schema Changes Shouldn't Be a Guessing Game

Silent Breakage

A type change in one service breaks three others. You find out in production.

No Audit Trail

Why was this field removed? Who approved it? No one knows.

Manual Coordination

Every schema change requires Slack threads and prayer.

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)

Captures @intent comments and detects semantic drift even when types don't change.

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.

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 and intent drift

Ship

git merge

Non-breaking changes merge; breaking changes require explicit approval

See It In Action

Real CLI output showing Dotto's powerful detection capabilities.

~/your-project

$ dotto impact UserDTO

Blast Radius for UserDTO:
----------------------------------------
Depth 1 (confidence: 0.95):
  - AuthService.authenticate()
  - ProfileController.getUser()

Depth 2 (confidence: 0.85):
  - NotificationService.sendWelcome()
  - BillingService.createInvoice()

Total affected: 4 downstream consumers

Enterprise Feature

Immutable Proof for Regulated Industries

Choose the proof backend that matches your compliance requirements.

None

Development, small teams

Local only

Coming Soon

Git

Most teams

Signed commits

Recommended

Hedera

Finance, healthcare, compliance

Blockchain consensus

Coming Soon

Sigstore

Open source, supply chain

Cryptographic signing

Hedera Consensus Service

Hedera is the only fully functional proof backend in Dotto. It anchors every schema change to Hedera Consensus Service, creating immutable, timestamped proof that can't be altered or disputed. Perfect for audit trails in finance, healthcare, and compliance-heavy environments.

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

Built for Teams

Stop breaking production. Start shipping with confidence.

Full Impact Analysis

See all downstream effects

Clear Ownership

Track who approved what

CI/CD Ready

Exit code 1 on breaking

Blame-Free Audits

Intent capture, not finger-pointing

Built for Compliance

Immutable audit trails that satisfy regulatory requirements.

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

Free, Open, Extensible

Open-source core. Enterprise compliance features available.

TypeScript Native

Full type safety

Pluggable Backends

Extend as needed

Active Development

Regular updates

npm install -g @natalietdg/dotto

Repository: github.com/natalietdg/dotto

Stop Guessing. Start Knowing.

Add Dotto to your CI pipeline in 5 minutes.

Read the Docs Star on GitHub

GitHub·NPM

Built with care by Natalie Leong · natalie@itsdotto.com