How do I add foreign key relationships?

Drag from one table's handle to another table's handle to create a relationship. By default it creates a one-to-many (1:N) relationship.

Is my data stored on a server?

No. Everything runs entirely in your browser. Export your schema as JSON or SQL to save your work locally.

Can I import Laravel migration files?

Yes! Upload one or more.php migration files and the tool will parse Schema::create, Schema::table, column additions, renames, and drops to generate a complete ER diagram with relationships.

Which SQL dialects are supported for export?

MySQL, PostgreSQL, SQLite, and SQL Server. Each dialect generates proper syntax including data type mappings, auto-increment, quoting style, and engine settings.

Can I design many-to-many relationships with a junction table?

Yes. You can create a junction (pivot) table manually with foreign keys pointing to both related tables, then draw one-to-many relationships from each parent table to the junction table. This is the standard pattern for many-to-many relationships in relational databases.

Does the ER diagram tool support auto-layout?

Yes. Click the Auto Layout button to automatically arrange all tables in a clean, readable layout. You can also manually drag tables to customize positions after auto-layout is applied.

Can I use this tool for PostgreSQL database design?

Absolutely. The designer supports PostgreSQL-specific data types and syntax. When exporting SQL, select PostgreSQL as the target dialect to get proper CREATE TABLE statements with serial types, constraints, and quoting.

ER Diagram Tool — Draw Entity Relationship Diagrams Online

How to design a schema in 4 steps

Add your tables

Press T or use the Table button. Name each table after the thing it stores.

Define columns and keys

In the inspector, pick a type for every column, mark the primary key, and toggle NN for required fields and UQ for unique ones.

Connect relationships

Drag from a column’s dot to a column on another table, then choose 1:1, 1:N or M:N in the inspector.

Export

Download SQL for PostgreSQL, MySQL, SQLite or SQL Server, or save the schema as JSON.

Keyboard shortcuts

Add table T

Select / pan V / H

Undo ⌘ Z

Redo ⇧ ⌘ Z

Fit to screen ⇧ 1

Delete selection ⌫

Pan the canvas Scroll

Zoom at the pointer ⌘ Scroll

Can I export my ER diagram as SQL?

Yes! Export to MySQL, PostgreSQL, SQLite, or SQL Server. The export includes CREATE TABLE statements with foreign key constraints and indexes.

What relationship types are supported?

The designer supports one-to-one, one-to-many, and many-to-many relationships between tables.

Can I import an existing schema?

You can import JSON schemas, SQL files (CREATE TABLE statements), or migration files from Laravel, Ruby on Rails, and Django.

How to Design Effective Database Schemas

Entity-Relationship (ER) diagrams are essential tools for database design. They visually represent tables, columns, and the relationships between entities in a database system.

Key Concepts

Entities (Tables) — Represent real-world objects like Users, Products, or Orders.
Attributes (Columns) — Properties of entities such as name, email, or price.
Relationships — Connections between entities (one-to-one, one-to-many, many-to-many).
Primary Keys — Unique identifiers for each record in a table.
Foreign Keys — References to primary keys in related tables.

Import & Export

Import SQL files from any database to visualize existing schemas
Import Laravel, Rails, or Django migration files to auto-generate diagrams
Export to MySQL, PostgreSQL, SQLite, or SQL Server with proper syntax
Foreign keys and indexes are included in SQL exports

Best Practices

Normalize your schema to reduce data redundancy
Use meaningful table and column names
Define proper data types for each column
Add indexes for frequently queried columns
Document relationships clearly

The ER Diagram Designer is a browser-based tool for creating entity-relationship diagrams without signing up or installing software. Whether you are planning a new database from scratch or documenting an existing one, the visual canvas lets you add tables, define columns with precise data types, and draw relationships between entities using drag-and-drop. Everything runs client-side, so your schema data never leaves your machine.

ER diagrams come in two main notation styles, and this tool draws relationships in crow's foot notation — the de-facto standard for modern database design and the style used by tools like dbdiagram.io and DataGrip. Crow's foot uses lines, circles, and forks at the line ends to denote cardinality (one, many, zero-or-one, one-or-many). The older Chen notation, originally proposed by Peter Chen in 1976 and still common in academic textbooks, uses diamond shapes for relationships and rectangles for entities; it is more expressive for documenting concepts but rarely used in production schema work. If you have a Chen-style diagram from coursework, this tool can reconstruct the equivalent crow's foot diagram from your CREATE TABLE statements — paste the SQL and the relationships are inferred from foreign keys.

Dialect-specific design considerations. Each major SQL dialect handles types and constraints differently, and a good ERD makes the right choice up-front rather than forcing migrations later. MySQL defaults to InnoDB, supports JSON columns since 5.7, and uses AUTO_INCREMENT for surrogate keys. PostgreSQL has the richest type system (arrays, JSONB with GIN indexing, native UUID, range types, custom enums) and uses SERIAL or GENERATED ALWAYS AS IDENTITY. SQLite's type system is permissive (any column accepts any type by default), making it forgiving for prototypes but a poor choice for high-concurrency production. SQL Server uses IDENTITY(1,1), has its own NVARCHAR vs VARCHAR distinction (Unicode vs not), and integrates tightly with.NET. The export menu in this tool lets you preview every dialect's CREATE TABLE output before committing to one.

Common ERD design patterns. A well-modeled schema usually relies on a small set of recurring patterns: one-to-many (one customer has many orders, modeled with a foreign key on the many side), many-to-many (orders contain many products and products belong to many orders, modeled with a junction/join table containing both foreign keys), polymorphic associations (a Comment can belong to a Post or a Photo, modeled with a type column plus an id column — easy in Rails, ergonomically harder in PostgreSQL), soft deletes (a deleted_at timestamp instead of physical row deletion, plus a partial index that excludes soft-deleted rows), and audit columns (created_at, updated_at, created_by, updated_by — populated by application or DB triggers). Bake these into your ERD before generating CREATE TABLE statements; retro-fitting them after data ships is painful.

One of the most powerful features is multi-format import. Paste SQL CREATE TABLE statements and the tool reconstructs the full schema with foreign key relationships. You can also upload Laravel migration files (.php), Rails migrations (.rb), or Django model files (.py) to auto-generate diagrams from your existing codebase. Once your diagram is complete, export production-ready SQL for MySQL, PostgreSQL, SQLite, or SQL Server. Need to format the generated SQL? Use the SQL Formatter to clean it up before committing to your repository.

The ER Diagram Designer pairs well with other developer tools on FindUtils. Convert your schema definitions to TypeScript interfaces with the JSON to TypeScript Converter, validate your API contracts with the GraphQL Schema Validator, or map out the broader system architecture using the Architecture Diagram tool. For state-driven workflows, the State Machine Designer complements database design by modeling application logic visually.

How it compares

MySQL Workbench is available but requires a desktop install, locks you into MySQL output, and has a steep UI learning curve. pgAdmin ships with PostgreSQL but is a database administration tool first and an ERD designer a distant second. dbdiagram.io (the closest competitor) requires sign-up for collaboration and a paid plan for private diagrams. Lucidchart handles ERDs but is a generic diagramming tool with a paid plan above 3 documents. Drawio is available but requires manual layout — no SQL import, no SQL export, no foreign-key inference.

The FindUtils ER Diagram Designer runs entirely in the browser with zero setup. No installation, no account creation, no paywall. No file-size limit on imports, no watermark on exports, no plan-tier gating for features like multi-dialect SQL generation, Laravel/Rails/Django migration parsing, or crow's-foot relationship inference. Design once and export to four major SQL dialects. The migration import feature is also unique: most online ERD tools cannot parse Laravel, Rails, or Django migration files directly. If you need a quick, private way to visualize or plan a database schema, this tool handles the job without sending your data to any server.