Tools

The tools developers use to interact with databases day-to-day: clients, GUIs, migrations, ORMs, observability.

Command-Line Clients

The shell is the most-used database interface for engineers who like terminals. psql for Postgres, mysql for MySQL, sqlite3 for SQLite, plus redis-cli, mongosh, cqlsh, duckdb, and clickhouse-client. pgcli and friends layer completion and history on top.

• psql, Postgres.

• mysql / mariadb, MySQL / MariaDB.

• sqlite3, SQLite.

• redis-cli, Redis.

• mongosh, MongoDB.

• cqlsh, Cassandra.

• duckdb, DuckDB.

• clickhouse-client, ClickHouse.

Worth setting up.

• ~/.psqlrc (or equivalent) for prompts, history, \timing, \pset formatting.

• pgcli / mycli / litecli, Python REPLs with completion.

• usql, one CLI for many databases.

Desktop GUIs

The graphical clients team members reach for when typing psql feels heavy. DBeaver covers everything; DataGrip is the JetBrains pick; TablePlus is macOS-friendly; pgAdmin and Compass and Workbench are vendor specifics. Browser-based options round out the cloud-product ecosystem.

• DBeaver, universal, free, JDBC-based.

• DataGrip, JetBrains commercial.

• TablePlus, macOS / Windows; many databases.

• pgAdmin, Postgres-specific.

• MongoDB Compass, RedisInsight, MySQL Workbench.

Browser-based.

• Postico, macOS Postgres.

• Beekeeper Studio, open source.

• Outerbase, Supabase Studio, Neon Console, cloud-product UIs.

Migrations

The discipline that turns schema changes into reviewable, re-runnable code. Cross-language tools like Flyway, Liquibase, and Atlas anchor the category; framework-native tools (Django, Rails, Alembic, Prisma) lean on the same idea. The patterns below codify how teams keep migrations safe in production.

• Cross-language: Flyway, Liquibase, Atlas, Skeema.

• Python: Alembic, Django migrations.

• Ruby on Rails built-in migrations.

• Node: Prisma migrate, Drizzle, Knex.

• Go: goose, golang-migrate, Atlas, sqlc.

• Rust: sqlx-migrate, refinery, Diesel migrations.

Patterns.

• Forward-only, never reverse in production; write a new forward migration to undo.

• Expand-and-contract for breaking changes.

• Run in CI, not by hand.

• Online schema change for big tables on MySQL: gh-ost or pt-online-schema-change.

ORMs and Query Builders

The library layer between application code and SQL. ORMs map objects to rows and hide SQL; query builders compose SQL programmatically; sqlc-style generators produce typed code from raw SQL. Each language has multiple options; pick the abstraction level the team can debug.

• Python: SQLAlchemy (mature), Django ORM, SQLModel, Tortoise, Peewee.

• Node / TS: Prisma, Drizzle, Kysely, MikroORM, TypeORM.

• Go: pgx + database/sql, sqlc, gorm, ent, bun, sqlx.

• Rust: sqlx, Diesel, SeaORM.

• Java: Hibernate, jOOQ, MyBatis.

• Ruby: ActiveRecord.

Tradeoffs in 2026.

• ORMs that hide SQL save time at small scale and trip up at big scale; the SQL is what executes.

• Type-safe query builders (sqlc, Drizzle, Kysely, sqlx w/ query!) are the modern sweet spot for languages with strong type systems.

Connection Pooling

Pool managers reuse database connections across requests so the database isn’t drowned by handshake overhead. pgbouncer is the Postgres standard; pgcat and ProxySQL are modern alternatives; in-app pools cover what the network proxies don’t.

Production-required for almost every relational database.

• pgbouncer, Postgres; the standard.

• pgcat, modern alternative with sharding.

• ProxySQL, MySQL.

• In-application pools, HikariCP (Java), pgx pool (Go), asyncpg / SQLAlchemy pools (Python).

Backups

The three flavors of database backup, each suited to different recovery needs. Logical dumps are portable but slow; physical backups support point-in-time recovery; snapshots are fastest. pgBackRest, WAL-G, and Restic round out the tool set. Test restores, always.

• Logical (pg_dump, mysqldump), portable, schema-aware, slow for big databases.

• Physical (pg_basebackup + WAL, MySQL XtraBackup), fast, exact, required for PITR.

• Snapshot (cloud disk snapshots), fastest if available; filesystem-consistent only if the disk supports it.

• pgBackRest, standard for Postgres.

• WAL-G, ships WAL to object storage.

• Restic, generic encrypted backup tool.

Test restore. A backup that’s never been restored is a hope.

Observability

The instrumentation that turns “the database is slow” from guess into diagnosis. pg_stat_statements aggregates per-query stats; pganalyze and OtterTune layer on tuning; Datadog and New Relic offer cross-database monitoring; the slow-query log plus EXPLAIN ANALYZE solve most cases.

• pg_stat_statements per-query stats in Postgres; turn it on.

• pganalyze, OtterTune, pgHero, Postgres tuning.

• Datadog Database Monitoring, New Relic, generic.

• Slow query log + EXPLAIN ANALYZE, the cheapest, most-used tool.

Local Development

The setups that let developers run real databases on their own machines. Compose spins up Postgres / MySQL / Redis with one file; Testcontainers provisions ephemeral databases per test; SQLite covers portable unit tests; embedded modes shorten test setup time further.

• Docker / Compose, spin up Postgres / MySQL / Redis with one file.

• Testcontainers, ephemeral databases per integration test.

• SQLite for unit tests where the schema is portable.

• Embedded modes for Postgres (pg_tmp) and Mongo (mongodb-memory-server) in test suites.

Production-shaped local development, with the same database engine and major version as production, catches a category of bugs nothing else does.