Event sourcing: stop losing history, start using it

Event sourcing: what it is (and no, it's not just logging)

With event sourcing, events are the source of truth. You don't store the "final state" of an object, you store everything that happened to it. Then you rebuild the state by replaying those events. Yes, like a replay. And no, it's not "just logs": a log tells a story, an event is the truth.

Basic example: instead of saving balance = 120, you record MoneyDeposited(200) then MoneyWithdrawn(80). The balance is a result, not a magic number from nowhere.

Why would you bother?

Because future-you will thank you when:

• you must audit who did what, when, and why,
• you want to debug by replaying reality,
• you need to rebuild a model after business changes,
• you want projections (read models) without wrecking your database.

In short: you pay some complexity now, so you stop improvising post-mortems later.

The core building blocks (no smoke)

• Event: an immutable fact, in the past. OrderPlaced, not PlaceOrder.
• Stream: the sequence of events for one aggregate.
• Aggregate: the domain object that applies events to rebuild state.
• Projection: a derived view (SQL, Elastic, cache, etc.) for fast reads.

When to use it (and when to avoid it)

Use it if:

• your domain changes often,
• history is critical,
• you need rock-solid traceability.

Avoid it if:

• your CRUD is basic,
• you don't need audit trails,
• your team is still discovering repositories.

Tiny Symfony starter example

We'll keep it simple: a Cart aggregate, events, and an in-memory event store. No full CQRS, no Kafka, no wizardry. Just the core.

1) Define the event

php
1<?php
2
3namespace App\Cart\Domain\Event;
4
5final class ItemAdded
6{
7    public function __construct(
8        public readonly string $cartId,
9        public readonly string $sku,
10        public readonly int $quantity,
11    ) {
12    }
13}

2) The aggregate that replays events

php
1<?php
2
3namespace App\Cart\Domain;
4
5use App\Cart\Domain\Event\ItemAdded;
6
7final class Cart
8{
9    private array $items = [];
10    private array $recordedEvents = [];
11
12    public static function reconstitute(array $events): self
13    {
14        $cart = new self();
15        foreach ($events as $event) {
16            $cart->apply($event);
17        }
18        return $cart;
19    }
20
21    public function addItem(string $cartId, string $sku, int $quantity): void
22    {
23        $event = new ItemAdded($cartId, $sku, $quantity);
24        $this->record($event);
25    }
26
27    public function recordedEvents(): array
28    {
29        return $this->recordedEvents;
30    }
31
32    private function record(object $event): void
33    {
34        $this->apply($event);
35        $this->recordedEvents[] = $event;
36    }
37
38    private function apply(object $event): void
39    {
40        if ($event instanceof ItemAdded) {
41            $this->items[$event->sku] = ($this->items[$event->sku] ?? 0) + $event->quantity;
42        }
43    }
44}

3) A minimal in-memory event store

php
1<?php
2
3namespace App\Cart\Infrastructure;
4
5final class InMemoryEventStore
6{
7    private array $streams = [];
8
9    public function append(string $streamId, array $events): void
10    {
11        $this->streams[$streamId] ??= [];
12        $this->streams[$streamId] = array_merge($this->streams[$streamId], $events);
13    }
14
15    public function load(string $streamId): array
16    {
17        return $this->streams[$streamId] ?? [];
18    }
19}

4) Usage inside a Symfony service

php
1<?php
2
3namespace App\Cart\Application;
4
5use App\Cart\Domain\Cart;
6use App\Cart\Infrastructure\InMemoryEventStore;
7
8final class AddItemToCart
9{
10    public function __construct(private InMemoryEventStore $eventStore)
11    {
12    }
13
14    public function __invoke(string $cartId, string $sku, int $quantity): void
15    {
16        $events = $this->eventStore->load($cartId);
17        $cart = Cart::reconstitute($events);
18
19        $cart->addItem($cartId, $sku, $quantity);
20
21        $this->eventStore->append($cartId, $cart->recordedEvents());
22    }
23}

There. No ORM, no cache, no parade. Just the central idea: events are the truth, state is a computed view. You can plug projections and Symfony Messenger listeners later if you want to play with the big kids.

Takeaways (if you have to explain it)

• Event sourcing stores history, not just the result.
• You rebuild state by replaying events.
• It's perfect for audit and evolving domains, pointless for boring CRUD.
• Symfony won't do it for you, but it lets you structure it cleanly.

If this feels heavy, good: you're trading immediate comfort for long-term clarity. You pay the cost now, or future-you pays it later. Your call.