Dolt logo

Dolt Review

Visit

Git for data - version control for databases with SQL interface

Dolt is a version-controlled SQL database that combines Git-style versioning with relational database functionality.

DoltHub·Founded 2018·From $5/moFree PlanFree TrialAI Coding ToolsAI AnalyticsAI CloudAI Data ToolsAI DevOps

AI Panel Score

7.8/10

6 AI reviews

Reviewed

AI Editor Approved

What is Dolt?

Dolt is a version-controlled SQL database that combines Git-style versioning with relational database functionality. Teams can track changes, create branches, and merge database schemas and data the way they do with code, while a MySQL-compatible server on port 3306 lets existing clients and applications connect unchanged. Cell-level diffs, commit history, time-travel queries, and pull requests for data changes provide a complete audit trail through plain SQL. The open-source core is free; DoltHub offers free hosting and a $5 per month Pro tier, DoltLab provides self-hosted deployment, and Hosted Dolt is a managed cloud option billed hourly from $50 per month; a free trial is available. TopReviewed's six-seat AI review panel scored it 7.8/10, praising branch, merge, and diff as real storage-engine primitives rather than bolt-on triggers while noting performance roughly 1.9 times slower than MySQL on Sysbench makes it a poor fit for latency-critical workloads. It best fits data teams that need auditable branching and merging of evolving datasets.

About Dolt

Dolt is a version-controlled SQL database that brings Git-like functionality to relational data management. It allows users to create branches, track changes, and merge database schemas and data with full version history, making it possible to collaborate on databases the same way developers collaborate on code.

The platform provides a MySQL-compatible SQL interface, enabling existing applications and tools to work with Dolt databases without modification. Users can perform standard database operations while automatically maintaining complete audit trails of all changes, including who made changes, when they were made, and what exactly was modified.

Dolt is designed for data teams, analysts, and developers who need to manage evolving datasets with accountability and collaboration features. It supports data sharing through DoltHub, a platform for hosting and discovering public datasets, and enables teams to work on the same database simultaneously through branching and merging workflows.

The system addresses challenges in data management where traditional databases lack proper version control, making it difficult to track data lineage, collaborate safely, or roll back problematic changes. Dolt combines the reliability of SQL databases with the collaborative power of Git version control.

Features

Analytics

  • Querying History

    Dolt databases allow querying data as it existed at any point in the commit history, using the commit as the unit of snapshot.

Collaboration

  • Clone, Push, Pull, Fetch Remotes

    Dolt supports Git-style distributed operations—clone, fetch, push, and pull—to synchronize database changes between local databases and remotes like DoltHub or DoltLab.

  • Merge Conflict Resolution via SQL

    When merges produce data or schema conflicts, users can inspect and resolve them using SQL system tables like dolt_conflicts and functions such as dolt_conflicts_resolve().

  • Pull Requests for Data Changes

    Dolt supports a pull request workflow where changes on a feature branch can be reviewed as a diff and then merged into a base branch, similar to GitHub pull requests.

Core

  • Branch Merging with Cell-Wise Diffs

    Dolt merges branches using a cell-wise merge strategy for data and detects schema and data conflicts, producing reasonable combinations of two branches' changes.

  • Commits and Version History

    Every change to data or schema is recorded as a commit with a parent reference, timestamp, and author, allowing full lineage tracking and time travel queries.

  • Dolt Workbench

    A browser-based, open-source SQL workbench for MySQL and PostgreSQL-compatible databases that adds version control features like diff review when connected to Dolt.

  • Git-Style Branching

    Dolt allows users to create branches of a database so tables can evolve independently for different users or use cases.

  • MySQL-Compatible SQL Server

    Dolt runs as a MySQL-compatible SQL server, allowing standard MySQL clients to connect and run queries against a Dolt database.

  • Prolly Tree Storage Engine

    Dolt stores data in content-addressed Prolly Trees, enabling branching, merging, cloning, and diffing that remain efficient regardless of database size.

Integration

  • Version Control via System Tables and Stored Procedures

    Dolt exposes Git-like version control operations in SQL through system tables (e.g., dolt_diff, dolt_status) for reads and stored procedures (e.g., dolt_commit, dolt_merge) for writes, following the dolt_<command> pattern.

Security

  • SSH and SQL-User Remote Authentication

    Dolt supports authenticating to remotes via SSH (system user-based) or via SQL users, passwords, and grants when connecting to a running sql-server remote.

Preview

Dolt desktop previewDolt mobile preview

Pricing Plans

Dolt (Open Source / Self-Hosted)

Free

For developers who want to run Dolt themselves; free and open source with optional paid enterprise support.

  • Free to use
  • Community support
  • Optional enterprise support

Dolt Enterprise Support

Contact sales

For organizations needing dedicated support and SLAs; requires contacting DoltHub sales for custom pricing.

  • Optional 24/7 support
  • Formal issue creation, prioritization, and resolution
  • Private Discord or Slack channel
  • Input into feature roadmap

Hosted Dolt (Trial Instance)

$50/monthly

Smallest Hosted Dolt preset (2 CPUs, 4 GB RAM) for trying managed Dolt on AWS without production-level cost; billed hourly at $0.07/hour, enterprise support included.

  • t2.medium instance running in EC2
  • 50 GB of storage
  • Monitoring, logging, backups, and incident management
  • Kept up to date with latest Dolt releases
  • Access to SQL Workbench
  • No time limit on trial

Hosted Dolt (Standard Instance)

$1,460/monthly

Popular Hosted Dolt preset (4 CPUs, 16 GB RAM) for production databases; billed hourly at $2.00/hour, with disk at $0.48/GB/month extra and enterprise support included.

  • 4 CPUs, 16 GB RAM
  • High network performance
  • $2.00 per hour
  • Disk space $0.48 per GB per month extra
  • Egress billed as a pass-through cost
  • Enterprise support included

Hosted Dolt (Enterprise Instance)

$17,403.20/monthly

Largest popular Hosted Dolt preset (32 CPUs, 256 GB RAM, 10 Gbps); billed hourly at $23.84/hour, with disk at $0.48/GB/month extra and enterprise support included.

  • 32 CPUs, 256 GB RAM
  • 10 Gbps network
  • $23.84 per hour
  • Disk space $0.48 per GB per month extra
  • Egress billed as a pass-through cost
  • Enterprise support included

DoltHub Free

Free

For individuals and open-source users who want to create and share public Dolt databases on DoltHub.

  • Create public databases of any size
  • Query, clone, and fork public databases
  • Community support
Popular

DoltHub Pro

$5/monthly

For individuals or small teams who need private Dolt database hosting on DoltHub.

  • Create private databases
  • First 100 MB of private storage free
  • 100 MB to 5 GB of private storage for $5/month
  • Additional storage past 5 GB billed at $1/GB/month
  • Enterprise support available

DoltLab Basic

Free

Free self-hosted DoltLab (DoltHub on your own network) for a small team on a single host.

  • Self-hosted on your own network
  • SQL interface, pull requests, and issues
  • Runs on a single host
  • Users sign up by email; teams and organizations disabled

DoltLab Enterprise

$5,000/monthly

Self-hosted DoltLab for companies at $5,000/month, bought through enterprise sales, with DoltHub Enterprise Support built in.

  • Single sign-on
  • Custom logo and email templates
  • Multi-host deployment for scale
  • S3 or GCS cloud storage backing
  • 24/7 support in a private Discord channel
  • Input into the DoltLab and Dolt roadmap

Dolt Workbench

Free

Free desktop SQL workbench for Dolt with Agent Mode.

  • Desktop SQL workbench
  • Agent Mode activated with your personal API key

AI Panel Reviews

The Decision Maker

The Decision Maker

Strategic bet, vendor viability, timing, adoption approval
7.6/10

Dolt is a genuinely unique versioned SQL database, but the vendor is small and lightly funded.

“Dolt is the only SQL database that branches and merges data, which is real differentiation. The catch is a small vendor with roughly $21 million raised and no obvious second source.”

DoltHub Inc is eight years old, founded 2018 in Santa Monica, and has raised about $21 million across two rounds, the last a Series B in 2021. That is a small war chest for an infrastructure vendor, and a board will ask about runway before it asks about features.

What you are buying is real, though. Dolt is the only SQL database that can branch and merge divergent data, and the dolt_diff system tables give you a native cell-level audit trail. PlanetScale runs a polished MySQL platform, but it does not merge data the way Dolt does. This is a genuine category of one.

However, that uniqueness cuts both ways. There is no second vendor if DoltHub stalls. Pricing is friendly: free open source, then $5 a month on DoltHub Pro past 100MB. Run a 90-day pilot on one non-critical dataset, confirm the open-source license is your fallback, then decide.

Competitive Positioning7.8

Being the only SQL database that merges data moves a team forward, though few peers have standardized on it yet.

Reputation Risk7.5

Apache-licensed open source plus a self-hosted DoltLab option means a board sees a defensible, not sketchy, choice.

Speed to Value7.8

A MySQL-compatible interface on port 3306 lets existing clients connect without rewrites, so payback comes fast.

Strategic Fit8.0

Branching, merging, and a native audit trail genuinely advance how a team manages evolving data rather than just cutting cost.

Vendor Viability6.8

Eight years in market is reassuring, but roughly $21 million raised and a small team make this a runway question.

Pros

  • Dolt is the only SQL database that can branch and merge divergent data, a real category of one.
  • MySQL-compatible interface lets existing clients and applications connect without modification.
  • Native cell-level diffs and history give teams a built-in audit trail without extra tooling.
  • Open-source Apache license and self-hosted DoltLab provide a credible fallback if the vendor stalls.

Cons

  • Roughly $21 million raised over two rounds is thin for a database infrastructure vendor.
  • Uniqueness means no second-source vendor if DoltHub loses momentum.
  • DoltLab Enterprise lists at $5,000/month, and standalone Dolt support is quote-only.

Right for

Data teams who need real version control and audit trails on evolving datasets.

Avoid if

Organizations who need a large, deeply funded database vendor for mission-critical systems.

The Domain Strategist

The Domain Strategist

Craft and strategy in the product's domain — adapts identity per category, same lens
8.0/10

Dolt makes a Merkle-DAG storage engine the substrate for treating data exactly like code.

“Dolt builds branch, merge, and diff into the storage layer rather than stapling them on as triggers. The architecture is a sound versioned-data bet, but Merkle-tree storage carries read overhead a plain primary doesn't.”

Dolt's whole pitch hangs on one structural decision: data isn't stored in B-trees but in a Merkle DAG, the same content-addressed structure Git uses. For a CTO weighing a versioned data substrate through 2029, that's what makes branch, merge, and Cell-Level Diff actual primitives rather than triggers stapled onto a normal MySQL.

The craft ceiling is real. The dolt_diff_<tablename> system tables and time-travel queries are exposed straight through SQL, so existing MySQL clients on port 3306 connect unchanged, and the engine has been generally available since 2019. Against Liquibase or Flyway, which version schema migrations only, Dolt versions the rows themselves.

But the catch is read performance. A Merkle-tree storage layer carries overhead a plain InnoDB primary doesn't, so Dolt fits audit-heavy and collaborative datasets rather than a hot transactional core. The Versioned MySQL Replica path lets you adopt it beside production instead of betting the OLTP path on it.

Category Positioning8.0

Dolt versions rows themselves where Liquibase and Flyway version only schema migrations, defining its own niche.

Domain Fit8.0

Branches, pull requests for data, and cell-level diffs match how engineers already reason about change.

Integration Surface8.0

A MySQL-compatible server on port 3306 and a Versioned MySQL Replica path let it slot beside existing stacks.

Long-term Implications7.5

MySQL compatibility limits lock-in, but Merkle-tree storage means read overhead is a permanent design constraint.

Strategic Depth8.5

Building version control into a Merkle-DAG storage engine is best-in-class craft, not a trigger-based shortcut.

Pros

  • Git-style branch, merge, and diff are real storage-engine primitives, not bolt-on triggers.
  • MySQL-compatible server on port 3306 lets existing clients and applications connect unchanged.
  • dolt_diff and dolt_history system tables give a native, cell-level audit trail through plain SQL.
  • Open-source core plus DoltLab self-hosting keeps data on-premises and limits vendor lock-in.

Cons

  • Merkle-tree storage carries read overhead that makes it a poor fit for a hot transactional core.
  • Hosted Dolt Standard runs $1,460/month, and private DoltHub storage past 5GB adds $1/GB.
  • DoltLab Enterprise, with support bundled, runs $5,000/month, steep for smaller teams.

Right for

Data teams who need a full audit trail and branch-merge workflows on evolving datasets.

Avoid if

Teams who need a high-throughput transactional database for a latency-sensitive production core.

The Finance Lead

The Finance Lead

Money, total cost of ownership, contracts, procurement math
7.9/10

DoltHub Pro just cut its sticker 10x to $5/month, and the open-source core costs nothing.

“The open-source Dolt engine is free to self-host, and DoltHub Pro now bills $5/month past the 100MB free tier. Hosted Dolt and $5,000/month DoltLab Enterprise are where real spend starts.”

Three things carry a price, and two are near-zero. The Dolt engine is open source, free on your own hardware. DoltHub Pro repriced in April 2026 — $50/month down to $5/month past a 100MB allowance, then $1/GB above 5GB.

The spend lives elsewhere. Hosted Dolt trial instances start at $50/month for 50GB, but production is instance-priced on AWS or GCP. The catch is the enterprise tier: DoltLab Enterprise lists at $5,000/month with support bundled. For a team of 50 running this in production, that or Hosted Dolt Standard at $1,460/month is the real year-3 number, not the workbench.

ROI is unusually legible. The dolt_diff system tables give a native, queryable audit trail, so compliance value is measurable, not hand-wavy. Compare PlanetScale, which versions schema only — Dolt versions the rows too.

Billing & Procurement7.5

Free tiers and a credit-card $5/month plan ease procurement, though Hosted Dolt production needs cloud-instance modeling.

Contract Flexibility8.0

Open-source self-host carries no lock-in, and the $5/month Pro tier is month-to-month with no term commitment.

Pricing Transparency8.5

Every tier is published — open source free, DoltHub Pro at $5/month, Hosted Dolt trial at $50, no sales call to see them.

ROI Clarity8.0

The dolt_diff and dolt_history system tables make audit and compliance value directly measurable in SQL.

Total Cost of Ownership7.5

Engine and Pro are near-zero, but Hosted Dolt is instance-priced and DoltLab Enterprise lists at $5,000/month.

Pros

  • The Dolt engine is open source and free to run on your own hardware with no seat cost.
  • DoltHub Pro repriced 10x cheaper in April 2026, now $5/month past a 100MB free allowance.
  • The dolt_diff system tables deliver a native, queryable audit trail that makes compliance ROI measurable.
  • All tiers are published, so procurement never starts with a sales call.

Cons

  • DoltLab Enterprise lists at $5,000/month, a steep floor for smaller teams.
  • Hosted Dolt production pricing is instance-based, so the real invoice needs cloud-cost modeling.

Right for

Data teams who need a queryable audit trail without a per-seat bill.

Avoid if

Teams who want managed production uptime but cannot budget $1,460 a month per instance.

The Domain Practitioner

The Domain Practitioner

Daily hands-on reality in the product's domain — adapts identity per category, same lens
7.7/10

Dolt gives data engineers real branch-and-merge for SQL, but raw query speed trails plain MySQL.

“Dolt makes a bad migration recoverable instead of a postmortem. But it pays for that with measurably slower reads on Sysbench.”

A data engineer judges a database by the migration script that quietly corrupted a table last Tuesday, not the demo. Dolt answers that directly. The dolt_history_<tablename> and dolt_diff_<tablename> system tables expose cell-level diffs in plain SQL, so you can query exactly which value changed, when, and by which commit hash instead of grepping backups.

The workflow fit is genuine. Long-lived branches give you write isolation, and every Git operation maps to a dolt_commit or dolt_merge stored procedure, so versioning works from any existing MySQL client on port 3306 without a separate CLI. Dolt can also run as a Versioned MySQL Replica, layering history onto a production primary without a migration.

The catch is throughput. Dolt 1.0, stable since May 2023, runs roughly 1.9X slower than MySQL on Sysbench, with reads hit hardest. Neon branches a Postgres database with copy-on-write and stays faster, but it cannot merge divergent data the way Dolt does.

Day-3 Reality7.8

A bad migration becomes a dolt_diff query and a revert, not a backup-restore postmortem.

Documentation Practitioner-Fit7.8

Docs cover system tables and merge conflict resolution with the depth of engineers who run the tool.

Friction Surface7.2

The roughly 1.9X Sysbench slowdown is a friction point felt across every read-heavy working day.

Power-User Depth7.7

Time-travel queries, long-lived branches, and CI testing scale well past the beginner clone-and-commit path.

Workflow Integration8.0

MySQL-compatible server on port 3306 and dolt_ stored procedures fit existing clients without new tooling.

Pros

  • Cell-level diff and history system tables turn data audits into ordinary SQL queries.
  • True branch-and-merge for data, not just schema, is unique among SQL databases.
  • Dolt can run as a replica of an existing MySQL primary, adding version control without a migration.
  • Open-source core plus free public DoltHub hosting lowers the cost of trying it.

Cons

  • Roughly 1.9X slower than MySQL on Sysbench makes it a poor fit for latency-critical workloads.
  • Hosted Dolt Standard lists at $2.00/hour, about $1,460/month, a steep step past the trial.

Right for

Data engineers who need auditable, mergeable changes to evolving datasets.

Avoid if

Teams running latency-sensitive production workloads on raw query speed.

The Power User

The Power User

Daily human experience, onboarding, polish, learning curve, reliability
7.8/10

Dolt makes a database behave like a Git repo, and most days that actually pays off.

“A SQL database where branch, merge, and diff work on rows instead of files. The catch is you have to learn version control habits before any of it feels natural.”

Most databases forget. You change a row, the old value is gone, and figuring out who touched it later means digging through logs that may not exist. Dolt remembers everything. Every change is a commit with a hash, an author, and a message, and the Cell-Level Diff shows you exactly what moved. That alone is worth a look.

The daily feel is familiar in a good way. It speaks MySQL on port 3306, so existing clients connect without fuss, and DoltHub gives you a GitHub-style web workbench with pull requests for data. Private storage is free to 100MB, then DoltHub Pro is $5 a month. PlanetScale also does database branching, but it branches schema, not the actual rows.

The catch is the learning curve. If branch and merge are not already muscle memory, day three is homework, not welcome. Launched in 2019, Dolt is steady, just not effortless on hour one.

Daily Polish7.8

Cell-Level Diff and a GitHub-style DoltHub workbench show real attention to the small repeated motions.

Learning Curve7.3

Powerful at month three once branching clicks, but discoverability in the first hour is thin.

Mobile Parity7.5

A version-controlled SQL database is desktop and server work, so mobile is reasonably out of scope.

Onboarding Experience7.0

First 10 minutes assume you already know Git branch and merge, so it leans toward homework.

Reliability Feel8.2

Every change is an immutable commit with hash, author, and timestamp, so nothing silently disappears.

Pros

  • Every data change is a commit with author, hash, and message, giving a real native audit trail.
  • MySQL-compatible on port 3306, so existing clients and apps connect without changes.
  • DoltHub adds a GitHub-style web workbench with pull requests for data, free for public databases.
  • Cell-Level Diff pinpoints exactly which value changed, when, and by whom.

Cons

  • The first hour assumes you already think in Git branches and merges.
  • DoltHub Pro costs $5 a month once private data passes 100MB.
  • Version control overhead is dead weight if you just need a plain database.

Right for

Data teams who already think in Git branches and commits.

Avoid if

People who just want a plain database without version control overhead.

The Skeptic

The Skeptic

Contrarian. Watch-outs, deal-breakers, broken promises, category patterns
7.6/10

A genuinely novel database that has stayed niche for seven years and counting.

“Dolt has shipped daily since 2018 and reached a stable 1.0 in 2023. The catch is a small market that has never gone mainstream.”

"World's first version controlled database" is the kind of superlative I usually discount. This time the claim mostly holds. Nobody else merges divergent SQL data branches.

The engineering is real. Dolt has shipped on a near-daily cadence since 2018, hit a stable 1.0 in 2023, and exposes cell-level diffs through dolt_diff_ system tables. But it runs roughly 1.9X slower than MySQL on Sysbench, by the team's own published numbers. Against PlanetScale, which gives you MySQL branching without the speed tax, that gap matters for hot paths.

Exit is clean — it speaks MySQL wire protocol, so you migrate out with a standard dump. The yellow flag is reach. Only $21M raised, Series B, and seven years in, version-controlled databases are still a niche, not a category.

Competitive Differentiation8.2

True SQL branch merging is a genuine gap no named competitor fills.

Exit Portability8.0

MySQL wire compatibility means migration out is a standard dump, not a rebuild.

Long-term Viability6.5

Only $21M raised and a niche market leave the three-year bet uncertain.

Marketing Honesty7.5

The "world's first version controlled database" claim is largely defensible, not pure hype.

Track Record Match7.8

Near-daily shipping since 2018 and a stable 1.0 in 2023 match a durable-vendor pattern.

Pros

  • Genuinely unique ability to branch and merge SQL data, not just schema.
  • MySQL wire compatibility keeps existing clients and exit paths intact.
  • Near-daily release cadence since 2018 signals a committed engineering team.
  • Cell-level diffs via dolt_diff_ tables give a native, built-in audit trail.

Cons

  • Roughly 1.9X slower than MySQL on Sysbench by the vendor's own numbers.
  • Version-controlled databases remain a niche after seven years on the market.
  • Modest $21M total raise limits the long-term viability cushion.

Right for

Data teams who need auditable branching and merging of datasets.

Avoid if

Teams who need raw query throughput at MySQL speed.

Buyer Questions

Common questions answered by our AI research team

Integration

Does Dolt work with existing MySQL tools?

Dolt offers a MySQL-compatible SQL interface, allowing it to work with existing MySQL tools.

Features

Can I create branches in a Dolt database?

Yes, Dolt allows users to create branches in a database, similar to version control systems for code.

Features

Does Dolt track full history of data changes?

Yes, Dolt maintains complete audit trails of all database modifications, tracking the full history of data changes.

Features

Can database schemas be merged like code in Dolt?

Yes, Dolt allows database schemas and data to be merged like code, similar to version control workflows.

Integration

What SQL interface does Dolt support?

Dolt supports a MySQL-compatible SQL interface.

Alternatives to Dolt

Who Dolt competes with, and how each one differs

l
lakeFS

Open-source version control for data lakes (branch/commit/merge over S3-style object storage) -- the same "Git for data" pitch as Dolt, but built for data-lake/analytics files rather than an OLTP-style SQL database.

P
PlanetScale

Serverless MySQL platform (built on Vitess) offering schema branching and deploy requests -- solves database *schema change* management for existing MySQL apps rather than versioning the data itself the way Dolt does natively.

N
Neon

Serverless Postgres with instant, copy-on-write database branching for dev/test workflows -- branching is ephemeral infrastructure tooling, not Dolt's row-level Git history with diff/blame/merge.

Product Information

  • Company

    DoltHub
  • Founded

    2018
  • Pricing

    From $5/mo
  • Free Trial

    Available
  • Free Plan

    Available

Platforms

webmacwindowslinux

About DoltHub

DoltHub is a Santa Monica-based company behind Dolt, an open-source version-controlled SQL database that behaves like Git for data.

Resources

Documentation
Blog

Also in AI Coding Tools