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.
AI Panel Score
6 AI reviews
Reviewed
AI Editor ApprovedApproved and published by our AI Editor-in-Chief after full panel analysis.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.
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.
Dolt databases allow querying data as it existed at any point in the commit history, using the commit as the unit of snapshot.
Dolt supports Git-style distributed operations—clone, fetch, push, and pull—to synchronize database changes between local databases and remotes like DoltHub or DoltLab.
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().
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.
Dolt merges branches using a cell-wise merge strategy for data and detects schema and data conflicts, producing reasonable combinations of two branches' changes.
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.
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.
Dolt allows users to create branches of a database so tables can evolve independently for different users or use cases.
Dolt runs as a MySQL-compatible SQL server, allowing standard MySQL clients to connect and run queries against a Dolt database.
Dolt stores data in content-addressed Prolly Trees, enabling branching, merging, cloning, and diffing that remain efficient regardless of database size.
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.
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.
For developers who want to run Dolt themselves; free and open source with optional paid enterprise support.
For organizations needing dedicated support and SLAs; requires contacting DoltHub sales for custom pricing.
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.
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.
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.
For individuals and open-source users who want to create and share public Dolt databases on DoltHub.
For individuals or small teams who need private Dolt database hosting on DoltHub.
Free self-hosted DoltLab (DoltHub on your own network) for a small team on a single host.
Self-hosted DoltLab for companies at $5,000/month, bought through enterprise sales, with DoltHub Enterprise Support built in.
Free desktop SQL workbench for Dolt with Agent Mode.
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.
Being the only SQL database that merges data moves a team forward, though few peers have standardized on it yet.
Apache-licensed open source plus a self-hosted DoltLab option means a board sees a defensible, not sketchy, choice.
A MySQL-compatible interface on port 3306 lets existing clients connect without rewrites, so payback comes fast.
Branching, merging, and a native audit trail genuinely advance how a team manages evolving data rather than just cutting cost.
Eight years in market is reassuring, but roughly $21 million raised and a small team make this a runway question.
Data teams who need real version control and audit trails on evolving datasets.
Organizations who need a large, deeply funded database vendor for mission-critical systems.
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.
Dolt versions rows themselves where Liquibase and Flyway version only schema migrations, defining its own niche.
Branches, pull requests for data, and cell-level diffs match how engineers already reason about change.
A MySQL-compatible server on port 3306 and a Versioned MySQL Replica path let it slot beside existing stacks.
MySQL compatibility limits lock-in, but Merkle-tree storage means read overhead is a permanent design constraint.
Building version control into a Merkle-DAG storage engine is best-in-class craft, not a trigger-based shortcut.
Data teams who need a full audit trail and branch-merge workflows on evolving datasets.
Teams who need a high-throughput transactional database for a latency-sensitive production core.
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.
Free tiers and a credit-card $5/month plan ease procurement, though Hosted Dolt production needs cloud-instance modeling.
Open-source self-host carries no lock-in, and the $5/month Pro tier is month-to-month with no term commitment.
Every tier is published — open source free, DoltHub Pro at $5/month, Hosted Dolt trial at $50, no sales call to see them.
The dolt_diff and dolt_history system tables make audit and compliance value directly measurable in SQL.
Engine and Pro are near-zero, but Hosted Dolt is instance-priced and DoltLab Enterprise lists at $5,000/month.
Data teams who need a queryable audit trail without a per-seat bill.
Teams who want managed production uptime but cannot budget $1,460 a month per instance.
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.
A bad migration becomes a dolt_diff query and a revert, not a backup-restore postmortem.
Docs cover system tables and merge conflict resolution with the depth of engineers who run the tool.
The roughly 1.9X Sysbench slowdown is a friction point felt across every read-heavy working day.
Time-travel queries, long-lived branches, and CI testing scale well past the beginner clone-and-commit path.
MySQL-compatible server on port 3306 and dolt_ stored procedures fit existing clients without new tooling.
Data engineers who need auditable, mergeable changes to evolving datasets.
Teams running latency-sensitive production workloads on raw query speed.
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.
Cell-Level Diff and a GitHub-style DoltHub workbench show real attention to the small repeated motions.
Powerful at month three once branching clicks, but discoverability in the first hour is thin.
A version-controlled SQL database is desktop and server work, so mobile is reasonably out of scope.
First 10 minutes assume you already know Git branch and merge, so it leans toward homework.
Every change is an immutable commit with hash, author, and timestamp, so nothing silently disappears.
Data teams who already think in Git branches and commits.
People who just want a plain database without version control overhead.
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.
True SQL branch merging is a genuine gap no named competitor fills.
MySQL wire compatibility means migration out is a standard dump, not a rebuild.
Only $21M raised and a niche market leave the three-year bet uncertain.
The "world's first version controlled database" claim is largely defensible, not pure hype.
Near-daily shipping since 2018 and a stable 1.0 in 2023 match a durable-vendor pattern.
Data teams who need auditable branching and merging of datasets.
Teams who need raw query throughput at MySQL speed.
Common questions answered by our AI research team
Dolt offers a MySQL-compatible SQL interface, allowing it to work with existing MySQL tools.
Yes, Dolt allows users to create branches in a database, similar to version control systems for code.
Yes, Dolt maintains complete audit trails of all database modifications, tracking the full history of data changes.
Yes, Dolt allows database schemas and data to be merged like code, similar to version control workflows.
Dolt supports a MySQL-compatible SQL interface.
Who Dolt competes with, and how each one differs
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.
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.
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.
Company
DoltHubFounded
2018Pricing
From $5/moFree Trial
AvailableFree Plan
AvailableDoltHub is a Santa Monica-based company behind Dolt, an open-source version-controlled SQL database that behaves like Git for data.