Persona: Senior Systems Architect / Lead Backend Engineer

Review Group: This material is best reviewed by a Technical Architecture Review Board or Senior Engineering Leadership. These individuals are responsible for long-term system maintainability, data integrity, and evaluating the trade-offs between traditional CRUD (Create, Read, Update, Delete) patterns and Event-Driven Architectures (EDA).

Abstract

In this technical retrospective from ElixirConf US 2025, Aaron Votre explores the architectural synergy between Phoenix LiveView and Event Sourcing within a startup environment (Bright Harbor). The talk identifies three primary failure modes of traditional CRUD architectures at scale: performance degradation due to query complexity, accidental code complexity from side-effect coupling, and fragile asynchronous workflows.

Votre argues that Event Sourcing—treating every state change as an immutable, append-only event—solves these issues by decoupling the "Write" and "Read" models. By using "Projectors" to transform event streams into optimized read tables and leveraging Elixir’s PubSub, the system achieves global reactivity and "constant time" reads. The presentation highlights a critical production incident where the immutable nature of the event log acted as a safety net, allowing the team to fix bugs and "replay" history to restore data integrity without manual database surgery. The session concludes that the combination of LiveView and Event Sourcing significantly reduces "innovation tokens" spent on maintenance, enabling faster feature delivery and robust business intelligence.

Strategic Summary: LiveView & Event Sourcing in Production

• 0:01:11 - The Architectural Shift: Transitioning from seven years of GraphQL/Absinthe to a pure Phoenix LiveView and Event Sourcing stack.

  • Takeaway: Traditional API layers (GraphQL) may be unnecessary overhead when leveraging the direct state management of LiveView.

• 0:03:02 - The "CRUD Trap" and Scaling Debt: Evolution of a system from simple queries to bloated, denormalized tables and thousand-line materialized views to maintain performance.

  • Takeaway: Writing data in the same format it is read (CRUD) creates inevitable performance bottlenecks as data volume reaches hundreds of millions of rows.

• 0:07:05 - Accidental Complexity in Side Effects: Business functions (e.g., make_purchase) become unreadable as they are forced to manage downstream side effects like Slack notifications, emails, and BI tasks.

  • Takeaway: Direct coupling of side effects to core business logic makes code fragile and difficult to modify.

• 0:08:59 - Background Job Fragility: Standard background jobs (e.g., Oban) often become coupled, where each job must know exactly what the "next" step in the workflow is.

  • Takeaway: Traditional job queues often result in redundant database reads/writes across workflow steps.

• 0:11:00 - The Event Sourcing Promise: Moving to an append-only, immutable JSON event store. Decoupling the Write Model (Event Store) from the Read Model (Projections).

  • Takeaway: Separating write and read concerns allows each to be optimized independently; reads become "constant time" because the data is pre-formatted for the view.

• 0:15:21 - Mechanics of Projectors: Introduction of "Projectors" as the bridge. They read events exactly once, in order, and update the Read Model.

  • Takeaway: Projections are "disposable." If the read logic needs to change, the table can be truncated and rebuilt from the event log.

• 0:21:52 - Integration with Phoenix PubSub: Using PubSub to broadcast projection updates to LiveView clients.

  • Takeaway: This architecture provides "globally reactive" applications by default; when a projector updates a record, all interested UI clients are updated simultaneously.

• 0:26:24 - The "Lost SMS" Incident (Crisis & Recovery): A production bug caused an SMS to be missing from the UI. Unlike CRUD, where data might be lost or require manual DB insertion, the data existed in the immutable event store.

  • Takeaway: Event Sourcing provides a built-in audit trail and "time travel" capability. Fixing a bug simply requires updating the projector and replaying the events.

• 0:32:00 - Performance & Spaghetti Reduction: Creating specific projections for specific pages (e.g., an Admin Timeline vs. a Client Timeline).

  • Takeaway: High-performance UIs are easier to build when the database schema perfectly matches the UI requirements, avoiding complex joins at runtime.

• 0:35:01 - Event-Driven Workflows: Replacing coupled jobs with "Handlers" that listen for specific events (e.g., FileUploaded triggers CategorizeFile).

  • Takeaway: Workflows become "plug-and-play," allowing developers to add new business requirements (like a new Slack alert) without touching the original codebase.

• 0:38:51 - Business Outcomes: Four engineers managed to build a robust, recoverable system with low operational costs and high-fidelity analytics.

  • Takeaway: Event sourcing enables a "Yes" culture by making complex requests (backfills, new metrics, audit logs) trivial to implement.