Postgres, Redis, DynamoDB, or a managed database?

Each replay uses a recreated ChatGPT interface so the placement can be read in its original conversational context. It is not a live or embedded chat.

1. ObservedJul 25, 2026Conversation1 turnsPlacementAfter turn 01 turns · After turn 0Replay chat
   Observed conversationJul 25, 2026 · interface recreation

   ChatGPTArchived view

   why do people use redis as a cache instead of just querying the database directly every time

   The short answer is: because databases are optimized for correctness and durability, while Redis is optimized for speed.

   Even if your database can answer a query quickly, repeatedly asking it for the same data wastes CPU, memory, disk I/O, and network bandwidth. A cache avoids that work.

   Here's an example.

   Suppose you have a product page:

   GET /products/123
   

   Without a cache:

   User
     ↓
   App
     ↓
   Database
   

   If 10,000 people request that product in one minute:

   • Database executes the same query 10,000 times.
   • It repeatedly parses the query, looks up indexes, loads rows, and sends results.
   • Your database becomes the bottleneck.

   With Redis:

   User
     ↓
   App
     ↓
   Redis
      ↓ (only if missing)
   Database
   

   The flow is:

   1. App checks Redis.
   2. If the product exists in Redis (a cache hit), return it immediately.
   3. If not (a cache miss):
      • Query the database.
      • Store the result in Redis for, say, 5 minutes.
      • Return the result.

   Now those 10,000 requests might become:

   • 1 database query
   • 9,999 Redis lookups

   ---

   Why is Redis so much faster?

   Redis stores everything in memory (RAM).

   Typical latency:

   System	Approximate latency
   Redis	0.1–1 ms
   SQL database	5–50+ ms

   The database often has to:

   • Read indexes
   • Check locks
   • Execute the query planner
   • Maintain transactions
   • Ensure consistency
   • Possibly read from disk

   Redis simply does:

   dictionary["product:123"]
   

   which is essentially a hash table lookup.

   ---

   Why not just keep everything in the database?

   Imagine a homepage that shows:

   • Trending posts
   • User profile
   • Notifications
   • Recommendations

   If 100,000 users refresh every minute, that's potentially millions of identical queries.

   Caching lets the database focus on:

   • writes
   • complex queries
   • transactions

   instead of repeatedly serving the same data.

   ---

   Doesn't the database cache things too?

   Yes.

   Most databases already cache:

   • frequently accessed pages
   • indexes
   • query execution plans

   But that doesn't eliminate the cost of:

   • executing the query
   • transaction handling
   • concurrency control
   • generating the result

   Redis skips almost all of that by storing the final value ready to return.

   ---

   Why not cache inside the application?

   You can, and many applications do.

   App
    ├── Memory cache
    └── Database
   

   The problem appears when you have multiple application servers:

             App 1
            /
   Users --- App 2
            \
             App 3
   

   Each server has its own memory.

   If App 1 caches a value, App 2 doesn't know about it.

   Redis acts as a shared cache:

             App 1
            /
   Users --- Redis
            \
             App 2
              \
               App 3
   

   Now every server sees the same cached data.

   ---

   Are there downsides?

   Yes.

   • Cached data can become stale.
   • You have to decide when to expire or invalidate cached values.
   • Redis uses RAM, which is more expensive than disk.
   • Cache invalidation is one of the trickier parts of system design.

   ---

   Rule of thumb

   Use the database as the source of truth.

   Use Redis to store:

   • frequently read data
   • expensive query results
   • sessions
   • rate-limiting counters
   • leaderboards
   • temporary data

   A common pattern looks like this:

   Read request
         │
         ▼
   Check Redis
         │
    ┌────┴────┐
    │ Hit     │ Miss
    ▼         ▼
   Return   Query DB
   data        │
               ▼
         Store in Redis
               │
               ▼
          Return data
   

   This architecture dramatically reduces load on the database and improves response times, especially for applications with many more reads than writes.

   

   DialogueDBAd

   Postgres, Redis, DynamoDB, or a managed database?Side-by-side comparison with code and the maintenance math.
2. ObservedJul 16, 2026Conversation1 turnsPlacementAfter turn 01 turns · After turn 0Replay chat
   Observed conversationJul 16, 2026 · interface recreation

   ChatGPTArchived view

   New project with heavy Postgres usage. Are you still on sqlc + database/sql, or have you moved to bun, gorm, or something else for better developer experience?

   For a new Go project with heavy PostgreSQL usage, my default recommendation has shifted a bit over the last couple of years, but not all the way to a full ORM.

   Here's where I currently land:

   Approach	Recommendation	Why
   sqlc + pgx	⭐ Strong default	Fast, type-safe, explicit SQL, excellent PostgreSQL support
   sqlc + database/sql	Good	Still solid, but I'd generally pick pgx today
   bun	Good for CRUD-heavy apps	Nice DX without as much ORM complexity
   gorm	Only if team already uses it	Powerful but more magic and harder to reason about SQL
   ent	Great for very large systems	Excellent schema tooling, but bigger commitment

   My current default

   For a PostgreSQL-first application:

   • PostgreSQL
   • pgx/v5
   • sqlc
   • golang-migrate (or Atlas if you want schema management)
   • Squirrel or a small query builder only when SQL becomes highly dynamic

   I no longer usually recommend database/sql unless there's a portability requirement.

   pgx gives you:

   • faster PostgreSQL driver
   • COPY support
   • LISTEN/NOTIFY
   • arrays
   • JSONB
   • enums
   • ranges
   • better error types
   • better PostgreSQL-specific features

   without giving up explicit SQL.

   ---

   Why I still like sqlc

   For large codebases, sqlc hits a sweet spot.

   You write SQL:

   -- name: GetActiveUsers :many
   SELECT *
   FROM users
   WHERE active = true
   ORDER BY created_at DESC;
   

   and get:

   users, err := q.GetActiveUsers(ctx)
   

   Advantages:

   • compile-time checking
   • generated typed structs
   • no reflection
   • SQL stays SQL
   • EXPLAIN plans are straightforward
   • DBAs can review queries

   When performance matters, this is hard to beat.

   ---

   When Bun is attractive

   I think Bun has become the ORM I'd recommend most often when someone does want one.

   It feels much more SQL-oriented than GORM.

   Example:

   err := db.NewSelect().
       Model(&users).
       Where("status = ?", "active").
       Order("created_at DESC").
       Scan(ctx)
   

   Things I like:

   • easy joins
   • eager loading
   • migrations
   • decent performance
   • much less magic than GORM

   If your application is mostly CRUD with moderate query complexity, Bun can significantly reduce boilerplate.

   ---

   Why I don't recommend GORM by default anymore

   GORM isn't bad, but over time I've seen recurring issues:

   • generated SQL can surprise you
   • reflection everywhere
   • harder debugging
   • implicit behavior
   • N+1 problems if you're not careful
   • performance overhead

   Teams often start quickly but later find themselves dropping into raw SQL for reporting or complex queries.

   At that point, they're maintaining both ORM code and handwritten SQL.

   ---

   For heavy PostgreSQL features

   If you're using things like:

   • JSONB
   • CTEs
   • recursive queries
   • window functions
   • ON CONFLICT
   • RETURNING
   • materialized views
   • full-text search
   • lateral joins
   • PostGIS

   I'd lean strongly toward sqlc.

   Those features map naturally to SQL, whereas ORMs often make them awkward or push you toward raw SQL anyway.

   ---

   A hybrid approach I like

   One pattern I've seen work well is:

   • sqlc for business queries
   • Bun only for simple CRUD/admin tooling

   That gives you excellent performance and type safety where it matters, while reducing boilerplate for the mundane parts.

   ---

   If I were starting a greenfield project today

   My stack would probably be:

   • Go 1.24+
   • PostgreSQL 16+
   • pgx/v5
   • sqlc
   • golang-migrate (or Atlas)
   • testcontainers-go for integration tests
   • goose instead of migrate if the team prefers SQL-first migrations

   Unless the application is almost entirely CRUD (an internal admin system, CMS, etc.), I would still choose sqlc + pgx over Bun or GORM. It keeps SQL as the source of truth, provides strong type safety, and scales well as query complexity grows.

   

   DialogueDBAd

   Postgres, Redis, DynamoDB, or a managed database?Side-by-side comparison with code and the maintenance math.