CRUD database:
  accounts table: { id: 1, owner: "Alice", balance: 750.00 }
  (history is gone — you can't know how it got to 750)

Event Sourced:
  events table:
    { accountId: 1, type: "AccountOpened",  amount: 0,    at: "2026-01-01" }
    { accountId: 1, type: "MoneyDeposited", amount: 1000, at: "2026-01-15" }
    { accountId: 1, type: "MoneyWithdrawn", amount: 250,  at: "2026-02-01" }
  current balance = replay all events = $750

// Events — immutable facts that happened
public abstract record AccountEvent(Guid AccountId, DateTimeOffset Timestamp);

public record AccountOpened(Guid AccountId, string Owner, DateTimeOffset Timestamp)
    : AccountEvent(AccountId, Timestamp);

public record MoneyDeposited(Guid AccountId, decimal Amount, DateTimeOffset Timestamp)
    : AccountEvent(AccountId, Timestamp);

public record MoneyWithdrawn(Guid AccountId, decimal Amount, string Reason, DateTimeOffset Timestamp)
    : AccountEvent(AccountId, Timestamp);

public class BankAccount
{
    public Guid   Id      { get; private set; }
    public string Owner   { get; private set; } = string.Empty;
    public decimal Balance { get; private set; }

    private readonly List<AccountEvent> _uncommittedEvents = [];
    public IReadOnlyList<AccountEvent> UncommittedEvents => _uncommittedEvents;

    // Reconstruct from event history
    public static BankAccount Restore(IEnumerable<AccountEvent> events)
    {
        var account = new BankAccount();
        foreach (var e in events) account.Apply(e);
        return account;
    }

    // Commands — validate and record events
    public void Open(string owner)
    {
        if (!string.IsNullOrWhiteSpace(Owner))
            throw new InvalidOperationException("Account already open");
        var e = new AccountOpened(Guid.NewGuid(), owner, DateTimeOffset.UtcNow);
        Apply(e);
        _uncommittedEvents.Add(e);
    }

    public void Deposit(decimal amount)
    {
        if (amount <= 0) throw new ArgumentException("Amount must be positive");
        var e = new MoneyDeposited(Id, amount, DateTimeOffset.UtcNow);
        Apply(e);
        _uncommittedEvents.Add(e);
    }

    public void Withdraw(decimal amount, string reason)
    {
        if (amount <= 0)   throw new ArgumentException("Amount must be positive");
        if (amount > Balance) throw new InvalidOperationException("Insufficient funds");
        var e = new MoneyWithdrawn(Id, amount, reason, DateTimeOffset.UtcNow);
        Apply(e);
        _uncommittedEvents.Add(e);
    }

    // Apply — mutate state from an event
    private void Apply(AccountEvent e)
    {
        switch (e)
        {
            case AccountOpened opened:
                Id    = opened.AccountId;
                Owner = opened.Owner;
                break;
            case MoneyDeposited deposited:
                Balance += deposited.Amount;
                break;
            case MoneyWithdrawn withdrawn:
                Balance -= withdrawn.Amount;
                break;
        }
    }
}

public interface IEventStore
{
    Task AppendAsync(Guid aggregateId, IEnumerable<AccountEvent> events, long expectedVersion);
    Task<IEnumerable<AccountEvent>> LoadAsync(Guid aggregateId);
}

public class AccountRepository(IEventStore store)
{
    public async Task<BankAccount> LoadAsync(Guid id)
    {
        var events = await store.LoadAsync(id);
        return BankAccount.Restore(events);
    }

    public async Task SaveAsync(BankAccount account, long expectedVersion)
    {
        await store.AppendAsync(account.Id, account.UncommittedEvents, expectedVersion);
    }
}

✓ Audit trail is legally required (banking, healthcare, compliance)
✓ Business needs to replay history or undo operations
✓ Temporal queries: "What was the balance on March 15?"
✓ Event-driven integration: publish events to other services
✓ Complex domain with many state transitions

✗ Simple CRUD apps — the overhead is massive
✗ Teams without distributed systems experience
✗ When you just need an audit log (add a log table instead)
✗ Data that changes constantly with no business need for history