DbSchema Features
One model your team designs, reviews & deploys from.
100+ databases — see any SQL or NoSQL schema as an ER diagram in minutes, without writing a query- Design offline — generate the physical schema for PostgreSQL, MySQL, MongoDB or any engine you support
- Schema in Git — review schema changes like the rest of your code, before they ship
- HTML documentation — opens in any browser, with no install and no license
- Compare environments — development against production, applying only the changes someone approved
- Queries without SQL — analysts and new joiners follow relationships without asking a developer
- One tool, not four — design, documentation, data and deployment in the same model
- Free Community Edition for everyone on the team
- No signup, no account
- 15-day Architect trial in the same installer
- Your model stays on your machine
Community Edition is free permanently, for as many people as you like — connect to any database, reverse engineer it, and work in the diagrams and the SQL editor. The trial adds the design, documentation and deployment tools on top.
Trusted by teams at
Watch Someone Do It First
See Inside Any of 100+ SQL and NoSQL Databases
All the databases your company uses, in one tool. Connect, and DbSchema reads the schema and draws it as a diagram — cloud, on-premise, or behind an SSH tunnel. It downloads the JDBC driver for you.
Access
Amazon Athena
Amazon Timestream
Apache Drill
Apache Druid
Apache Ignite
Apache Pinot
Apache Solr
Aurora MySql
Aurora PostgreSQL
Azure Synapse
AzureSQL
Cache
Cassandra
ClickHouse
Cockroach
Couchbase
CrateDB
CSV Files
CTreeAce
CUBRID
DaffodilDb
Databricks
Dataverse
Db2
DBF, FoxPro and xBase
Derby
DocumentDB
Dremio
DuckDB
DynamoDB
Elasticsearch
EnterpriseDB
Exasol
Fabric Lakehouse
Filemaker
Firebird
Firebolt
FrontBase
Google AlloyDB
GoogleBigQuery
GoogleCloudSpanner
Greenplum
H2
HBase
Hive
Hologres
HSql
Impala
InfluxDB
Informix
Ingres
Interbase
JDataStore
Kafka
MariaDb
MarkLogic
MemSQL
Mimer
MonetDB
MongoDb
MySql
Neo4j
Neon
NuoDB
Oracle
OrientDb
Pervasive
PlanetScale
PointBase
PostgreSQL
QuestDB
Redis
Redshift
Salesforce
SAP Adaptive Server
SAP Hana
SAP Max DB
ScyllaDB
SingleStore
SnappyData
Snowflake
SQL Anywhere
SqlBase
SQLite
SqlServer
Starburst
Supabase
TarantoolDB
Teradata
ThoughtSpot
Tibero
TiDB
TimescaleDB
Transbase
Trino
Vertica
VoltDB
Xata
Yellowbrick
YugabyteDB
Visual Database Design and ER Diagrams
A schema drawn on a whiteboard stays on the whiteboard. Design it in DbSchema and the same model gives you the SQL, the documentation and the deployment — with everyone following the same naming and type rules.
Give every subsystem its own diagram
- A new developer sees the ten tables their feature touches, not all four hundred.
- One diagram per subsystem, showing tables, columns, keys and relationships.
Design once, deploy to any database
- Add a second database engine without designing twice.
- One model generates the schema for PostgreSQL, MySQL, MongoDB or any supported engine, with your naming and type rules.
Bring a legacy schema under design
- An old DDL file becomes a model your team can read and change.
- Import the SQL, edit it visually, export clean DDL.
Built for the Databases That Actually Matter
Thousands of tables. Behind a firewall. Changed by several people who never meet. That is the database that needs careful design, and it is the one DbSchema is built for.
Thousands of tables, still reviewable
- Find your way around a schema with thousands of tables.
- Group related tables, auto-arrange the layout, keep one diagram per subsystem.
Your database never leaves its network
- No cloud account, nothing uploaded, no data-processing agreement.
- Connect over SSL/TLS or an SSH tunnel. The model is a file on your own machine or Git server.
Review a schema change like a pull request
- Schema changes get reviewed like code, before they ship.
- Commit the model to Git, diff and merge branches, and share HTML or PDF documentation with everyone else.
Database Documentation, So the Schema Outlives the People Who Built It
Right now, one person can explain your schema. If they leave, that knowledge goes with them. Publish the schema once as interactive HTML and anyone can read it — new developers, analysts, auditors — without asking.
Onboarding without a senior developer
- New developers, analysts and auditors read the schema themselves.
- One HTML5 package with diagrams, columns, types and comments. Opens in any browser.
Commit the schema with the code
- The schema gets a history and an author, like the rest of the project.
- Commit, push, diff and merge the model from inside DbSchema, in your existing repository.
Licenses that follow the person, not the machine
- Install DbSchema on every machine, pay only for the people using it.
- Runs on your own network, for machines with no internet access.
Write SQL and Explore Data Without Memorizing the Schema
Analysts and new developers stop asking the one person who knows how the tables join. DbSchema already knows the relationships — follow them, build the query by dragging, or write SQL with autocomplete that knows your schema.
No SQL Required
Anyone on the team can open a table and read the rows.
Let analysts answer their own questions
- Follow a customer to their orders and invoices without writing a join.
- Uses the real foreign keys, or virtual ones you define.
Write SQL with the schema in front of you
- Write correct SQL against a schema you did not design.
- Autocomplete that knows your tables and columns. Edit results inline, export to CSV, Excel or JSON.
Get the query right the first time
- The joins come from the model, not from memory.
- Drag tables, joins and filters into place, then read the SQL before it runs.
Never Deploy a Schema Change Nobody Reviewed
Production drifts. Somebody added a column by hand in March and told nobody. DbSchema shows exactly how each environment differs from the model, statement by statement, and applies only what someone approved.
Exists in the Model
Missing in the Database
See every difference before anything changes
- Spot the drift between development, test and production early.
- Apply only the approved changes, or pull the database back into the model.
Move one reviewed change through every environment
- The change that passed test is the one that reaches production.
- The same diff at every stage, with the SQL visible before it runs.
Ship schema changes as reviewable SQL
- The DBA gets a script to review instead of a request to interpret.
- Diff two model versions or two environments, and get the migration in the target dialect.
The Jobs Your Team Keeps Doing By Hand
Filling a test database. Regenerating documentation after every change. Finding what is locking production. Each takes someone twenty minutes every week — or runs on a schedule and takes nobody any time at all.
Set It Up Once
Test data, scheduled jobs and database monitoring that run without you.
Test against data that behaves like production
- Realistic test data, instead of test1, test2, asdf.
- Reusable patterns and regex rules fill related tables in foreign-key order.
Chores that run on their own
- Regenerate documentation, sync schemas and reload test data on a schedule.
- Groovy scripts with full access to the model and the connection.
See what your database is doing right now
- Find the session holding the lock, while it still matters.
- Sessions, locks, users and disk usage, in DbSchema or in DbSchemaCLI on a server.
Now with AI Assistant
Ask what a table is for. Describe the query you want in plain English. Let it write the column comments nobody has had time for. The AI reads your own schema, so its answers use your table names. On any paid edition you can use your own API key, so your schema goes only to the model you chose.
See Release Notes
See your own schema as a diagram in about ten minutes
Download, connect, and DbSchema draws your database. Free Community Edition for the whole team, no signup, and a 15-day Architect trial in the same installer — nothing uploaded, nothing to cancel.