Domain‑Driven Design, ORMs, and Developer Experience with PostgreSQL

🏛️ Era 1: The Database as Central Hub

Characteristics:

    [Application A]      [Application B]      [Application C]
           ↓                    ↓                    ↓
      ┌────────────────────────────────────────────────────┐
      │               CENTRAL POSTGRESQL                   │
      │  • Normalized schemas (3NF)                       │
      │  • Referential integrity constraints              │
      │  • Stored procedures for business logic           │
      │  • Views for application‑specific access          │
      └────────────────────────────────────────────────────┘
                

Strengths:

• Single source of truth – Consistent data across applications
• Data integrity – Constraints enforced at database level
• Shared business logic – Stored procedures reusable by all apps
• Cross‑application reporting – Direct SQL joins across domains

Pain Points:

• Monolithic schema changes – Affects all applications
• DBA bottleneck – Every change requires DBA approval
• Application‑database impedance – Object‑relational mismatch
• Tight coupling – Applications depend on shared schema

🧠 Paradigm Shift: Domain‑Driven Design

Introducing Bounded Contexts – each with:

Key DDD Concepts for Database Professionals:

// Order aggregate:
{
  order_id: 123,
  customer_id: 456,
  line_items: [...],
  shipping_address: {...},
  payment_status: "paid"
  // All updated atomically
}

class Order {
  private List items;
  
  public void addItem(Product p, int qty) {
    // Business logic here
    items.add(new OrderItem(p, qty));
    this.calculateTotal();
  }
}

// PostgreSQL with JSONB:
CREATE TABLE orders (
  id UUID PRIMARY KEY,
  aggregate JSONB NOT NULL,
  version INT DEFAULT 1
);

-- Atomic update of entire aggregate
UPDATE orders 
SET aggregate = '{"items":[...], "total":...}'
WHERE id = ? AND version = ?;

⚡ How PostgreSQL Adapted: ORMs + JSONB

1. The ORM Revolution

// Java + JDBC boilerplate
PreparedStatement stmt = conn.prepareStatement(
    "INSERT INTO orders (id, customer_id, total) VALUES (?, ?, ?)"
);
stmt.setObject(1, order.getId());
stmt.setObject(2, order.getCustomerId());
stmt.setBigDecimal(3, order.getTotal());
stmt.executeUpdate();

// Plus: line_items, addresses tables...
// 50+ lines for one aggregate

// Java + Hibernate
@Entity
@Table(name = "orders")
class Order {
    @Id UUID id;
    @OneToMany List items;
    @Embedded Address shippingAddress;
    
    // Business logic methods...
}

// Save entire aggregate:
entityManager.persist(order);
// 5 lines, includes all related objects

2. PostgreSQL JSONB: Document‑Style Aggregates

CREATE TABLE order_aggregates (
    id UUID PRIMARY KEY,
    version INTEGER DEFAULT 1,
    aggregate JSONB NOT NULL,
    created_at TIMESTAMPTZ DEFAULT NOW(),
    -- Index for common queries
    CONSTRAINT valid_order 
      CHECK (aggregate ? 'customer_id')
);

-- Find high-value orders
SELECT * FROM order_aggregates
WHERE (aggregate->>'total')::numeric > 1000;

-- Update specific field
UPDATE order_aggregates
SET aggregate = jsonb_set(
    aggregate,
    '{status}',
    '"shipped"'
)
WHERE id = ?;

-- GIN index for flexible queries
CREATE INDEX idx_gin_aggregate 
ON order_aggregates USING GIN (aggregate);

-- Expression index for performance
CREATE INDEX idx_total 
ON order_aggregates 
((aggregate->>'total')::numeric);

🛠️ Modern Developer Experience

Development Flow with DDD + PostgreSQL:

1. Domain Modeling

   Identify aggregates, bounded contexts with domain experts.

2. Database‑per‑Service

   Each bounded context gets its own PostgreSQL database.

3. Schema‑as‑Code

   Database schema defined in migration files (Liquibase/Flyway).

4. Test‑Driven Development

   Aggregate tests with in‑memory H2 → PostgreSQL integration tests.

5. Containerized Development

   docker‑compose with PostgreSQL + application containers.

Communication Bridge: DBAs ↔ Developers

🎯 Hands‑On Demos

-- Traditional (7 tables)
CREATE TABLE orders (...);
CREATE TABLE order_items (...);
CREATE TABLE customers (...);
CREATE TABLE addresses (...);
CREATE TABLE payments (...);
CREATE TABLE shipments (...);
CREATE TABLE order_history (...);

-- DDD‑Style (2 tables)
CREATE TABLE orders (
    id UUID PRIMARY KEY,
    aggregate JSONB,  -- items, addresses embedded
    version INT
);
CREATE TABLE customers (
    id UUID PRIMARY KEY,
    details JSONB     -- contact info, preferences
);

-- V1__initial_schema.sql
CREATE TABLE order_aggregates (...);

-- V2__add_versioning.sql
ALTER TABLE order_aggregates 
ADD COLUMN version INTEGER DEFAULT 1;

-- V3__add_status_index.sql
CREATE INDEX idx_aggregate_status 
ON order_aggregates ((aggregate->>'status'));

@Repository
public class OrderAggregateRepository {
    
    @PersistenceContext
    private EntityManager entityManager;
    
    public Order findById(UUID id) {
        // Returns Order with all line items loaded
        return entityManager.find(Order.class, id);
    }
    
    public void save(Order order) {
        // Saves entire aggregate graph
        entityManager.persist(order);
    }
}

🎓 Key Takeaways