What is Space-Based architecture, and when is it justified?

package com.bank.grid;

import java.math.BigDecimal;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

/**
 * Simplified in-memory grid that each processing unit uses.
 * In production this would be Hazelcast IMap or Apache Ignite IgniteCache.
 */
public class InMemoryAccountGrid {

    private final Map<String, BigDecimal> balances = new ConcurrentHashMap<>();

    public void put(String accountId, BigDecimal balance) {
        balances.put(accountId, balance);
    }

    public BigDecimal get(String accountId) {
        return balances.getOrDefault(accountId, BigDecimal.ZERO);
    }

    public Map<String, BigDecimal> snapshot() {
        return Map.copyOf(balances);
    }
}

Expected: each put/get operates in microseconds from RAM,
no database round trip on the hot path.

package com.bank.service;

import com.bank.grid.InMemoryAccountGrid;
import java.math.BigDecimal;

public class TradeOrderService {

    private final InMemoryAccountGrid grid;

    public TradeOrderService(InMemoryAccountGrid grid) {
        this.grid = grid;
    }

    public void placeOrder(String accountId, BigDecimal amount) {
        // Hot path: write to in-memory grid, NOT the database
        BigDecimal current = grid.get(accountId);
        grid.put(accountId, current.subtract(amount));
        // Data writer flushes to DB asynchronously in background
    }
}

Expected: placeOrder completes in microseconds.
The database is updated later by a background data writer.

package com.bank.grid;

import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Map;

public class AsyncDataWriter implements Runnable {

    private final InMemoryAccountGrid grid;
    private final Connection dbConnection;

    public AsyncDataWriter(InMemoryAccountGrid grid, Connection dbConnection) {
        this.grid = grid;
        this.dbConnection = dbConnection;
    }

    @Override
    public void run() {
        Map<String, BigDecimal> snapshot = grid.snapshot();
        try (PreparedStatement ps = dbConnection.prepareStatement(
                "UPDATE accounts SET balance = ? WHERE account_id = ?")) {
            for (Map.Entry<String, BigDecimal> entry : snapshot.entrySet()) {
                ps.setBigDecimal(1, entry.getValue());
                ps.setString(2, entry.getKey());
                ps.addBatch();
            }
            ps.executeBatch();
            System.out.println("Flushed " + snapshot.size() + " entries to database");
        } catch (Exception e) {
            System.err.println("Flush failed, will retry: " + e.getMessage());
        }
    }
}

Expected: Flushed 5000 entries to database
Runs every few seconds in the background.

package com.bank.grid;

public class ProcessingUnitScaler {

    private int activeUnits = 1;
    private static final int TRADES_PER_UNIT = 10_000;

    public void scaleUp(int additionalUnits) {
        activeUnits += additionalUnits;
        System.out.println("Scaled to " + activeUnits + " units, capacity: "
                + (activeUnits * TRADES_PER_UNIT) + " trades/sec");
    }

    public void scaleDown(int removeUnits) {
        activeUnits = Math.max(1, activeUnits - removeUnits);
        System.out.println("Scaled down to " + activeUnits + " units");
    }
}

Scaled to 5 units, capacity: 50000 trades/sec
Scaled down to 2 units

package com.bank.grid;

// WRONG: assuming grid and DB are always in sync
public class WrongAssumption {
    void checkBalance(String accountId) {
        // Grid says balance is 50000, DB still shows 80000
        // because the flush has not happened yet
        // Do NOT use DB balance for authoritative decisions during burst
    }
}

// CORRECT: understand the eventual consistency window
public class CorrectApproach {
    void checkBalance(String accountId, InMemoryAccountGrid grid) {
        // During burst, the grid IS the source of truth
        // The DB is eventually consistent and catches up after the burst
        System.out.println("Grid balance (authoritative during burst): "
                + grid.get(accountId));
    }
}

package com.bank.service;

// WRONG: jumping to space-based architecture for a 200 req/sec service
// This is massive over-engineering
public class OverEngineered {
    // Setting up Hazelcast cluster, data writers, messaging grid
    // for a service that a single PostgreSQL instance handles easily
}

// CORRECT: exhaust simpler options first
public class RightApproach {
    // Step 1: Add Redis cache for read-heavy data
    // Step 2: Add read replicas for read scaling
    // Step 3: Shard the database for write scaling
    // Step 4: ONLY if all three fail, consider space-based architecture
}

package com.bank.grid;

import java.math.BigDecimal;

public class DurabilityConfig {

    // Replication factor: how many copies of each partition
    private static final int REPLICATION_FACTOR = 2;
    // Write-behind log for crash recovery
    private static final boolean WRITE_BEHIND_LOG = true;
    // Flush interval in milliseconds
    private static final long FLUSH_INTERVAL_MS = 2000;

    public static void main(String[] args) {
        System.out.println("Replication factor: " + REPLICATION_FACTOR);
        System.out.println("Write-behind log enabled: " + WRITE_BEHIND_LOG);
        System.out.println("Flush interval: " + FLUSH_INTERVAL_MS + "ms");
        System.out.println("Data loss window: up to " + FLUSH_INTERVAL_MS + "ms of writes");
    }
}

Replication factor: 2
Write-behind log enabled: true
Flush interval: 2000ms
Data loss window: up to 2000ms of writes