Eventify — Event-Driven Order Processing System

Overview

Eventify is a backend-focused microservices system built to demonstrate how modern distributed platforms reliably process orders across independent services such as inventory and payments.

The system uses an event-driven architecture with Saga orchestration and the Transactional Outbox pattern to maintain consistency under partial failures and duplicate message scenarios.

The primary goal was to gain hands-on experience with realistic distributed system failure modes and recovery strategies.

Problem Statement

Traditional monolithic order systems struggle when:

• services fail independently
• messages are duplicated
• partial failures leave data inconsistent
• synchronous chains increase latency and fragility

In real-world platforms, global transactions are impractical, so systems must rely on eventual consistency and reliable messaging.

Eventify explores how to design such a system safely.

Architecture Overview

High-Level Flow

1. Client creates order via API Gateway
2. Order Service persists order + outbox event
3. Inventory Service reserves stock
4. Payment Service processes payment
5. Saga orchestrator determines final state
6. Compensation triggered on failure

Core Services

• API Gateway
• Auth Service
• Order Service (Saga orchestrator)
• Inventory Service
• Payment Service
• Outbox Publisher Worker
• Message Broker (Kafka)

Design Goal: isolate failures while maintaining eventual consistency.

---

Key Technical Decisions

Event-Driven Communication (Kafka)

Why:

• reduces temporal coupling
• enables replay capability
• improves failure isolation

Trade-off: increased system complexity and eventual consistency handling.

---

Orchestrated Saga Pattern

Used Order Service as central orchestrator.

Benefits:

• explicit failure handling
• easier debugging for learning system
• deterministic workflow

Trade-off: orchestrator can become coordination hotspot at scale.

---

Transactional Outbox Pattern

Dual-write problem avoided by writing business data and events in the same DB transaction.

Result:

• no lost events
• reliable publishing
• replay-safe event delivery

---

Idempotent Consumers

Each service maintains processed_events table.

Purpose:

• safe retries
• duplicate message protection
• effectively-once processing semantics

---

Reliability & Fault Tolerance

The system was designed with failure scenarios in mind.

Implemented Mechanisms

• at-least-once delivery
• exponential retry with backoff
• dead letter queue (DLQ)
• idempotent event handling
• service-level database isolation
• correlation IDs for tracing

These mechanisms allow the workflow to recover from partial failures without corrupting state.

---

Challenges Faced

Distributed Transaction Coordination

Coordinating inventory and payment without global transactions required careful Saga state management.

Approach: explicit state machine in Order Service with compensation logic.

---

Reliable Event Publishing

Ensuring DB write and event publish remain consistent.

Approach: implemented Transactional Outbox with background publisher.

---

Handling Duplicate Messages

Kafka can deliver messages more than once.

Approach: added idempotency checks using processed event store.

---

What I Learned

• practical event-driven architecture patterns
• Saga orchestration trade-offs
• outbox-based reliable messaging
• designing idempotent consumers
• thinking in failure-first distributed workflows

---

Future Improvements

Planned enhancements:

• add OpenTelemetry distributed tracing
• introduce Prometheus + Grafana metrics
• implement schema registry (Avro/JSON Schema)
• run k6 load testing with published metrics
• evaluate Kubernetes deployment
• add circuit breakers and rate limiting

---

Current Status

• Core Saga workflow implemented
• Outbox publisher working
• Duplicate protection in place
• Docker Compose setup available

(Load testing and production metrics planned.)

---

My Role

As the solo developer, I:

• designed the service boundaries
• implemented Saga orchestration
• built transactional outbox publisher
• implemented Kafka consumers and retries
• containerized services with Docker Compose

---

Key Takeaway

Eventify strengthened my understanding of how distributed systems maintain consistency using asynchronous workflows, and highlighted the importance of idempotency, reliable messaging, and failure-aware design.