Production-grade distributed payment processing system built with Java, Spring Boot 3, Kafka, and event-driven microservices architecture.
Designed to handle high throughput, fault tolerance, and real-world distributed systems challenges, including idempotency, saga orchestration, observability, and reliable event publishing.
This project simulates a real-world payment processing pipeline where transactions are asynchronously validated through a fraud detection service.
The system embraces event-driven communication and eventual consistency, ensuring resilience and scalability under failure scenarios.
Client
↓
Payment Service
↓
Outbox Table → CDC Publisher
↓
Kafka (payment-topic)
↓
Fraud Service (Saga Step)
↓
Kafka (fraud-result)
↓
Payment Orchestrator (Saga)
↓
PostgreSQL
- Event-driven microservices
- Saga orchestration for distributed transactions
- Outbox Pattern for reliable publishing
- Strong consistency boundaries + eventual consistency
Kafka enables decoupling, scalability, and asynchronous communication between services.
Distributed transactions are coordinated via saga orchestration, ensuring consistency across services without relying on 2PC.
Guarantees atomicity between database writes and event publishing, avoiding message loss.
- Prevents duplicate processing
- Ensures data integrity under concurrent consumption
- Handles reprocessing safely
Event contracts are versioned and validated, ensuring compatibility between producers and consumers.
The system includes end-to-end distributed tracing:
- Micrometer + Spring Boot 3 Observability
- Correlation ID propagation across services
- Trace continuity across Kafka topics
- Structured logging aligned with trace context
👉 Enables full visibility of: Payment → Fraud → Result lifecycle
- Duplicate message processing (idempotency)
- Reliable event publishing (Outbox Pattern)
- Distributed transaction consistency (Saga)
- Traceability across async boundaries
- Concurrent processing with data integrity
- Event schema evolution (Schema Registry)
- Distributed tracing with Micrometer
- Correlation ID propagation across async flows
- Saga orchestration for payment lifecycle
- Outbox Pattern with transactional guarantees
- Idempotent consumers with database safeguards
- Pessimistic locking to prevent race conditions
- Schema Registry for event evolution
- Clean separation of bounded contexts (Payment / Fraud)
- Java + Spring Boot 3
- Apache Kafka
- PostgreSQL
- Docker / Docker Compose
- Micrometer (Observability)
- Schema Registry (Avro/Protobuf)
- GitHub Actions (CI/CD automation)
- Payment is created and stored
- Event is written to Outbox table
- Outbox publisher sends event to Kafka
- Fraud service consumes and evaluates
- Fraud result is published
- Saga orchestrator updates payment status
- At-least-once delivery
- Idempotent processing
- Atomic event publishing (Outbox)
- Safe retries without side effects
- Consistency via Saga orchestration
- Automated Pull Request pipeline using GitHub Actions
- Continuous integration for build and validation
- Ready for extension into full deployment pipelines
- Docker
- Docker Compose
docker-compose up --build| Topic | Description |
|---|---|
| payment-topic | Payment events |
| fraud-result | Fraud analysis results |
- Rate limiting (API gateway level)
- Backpressure strategies (consumer lag control)
- Circuit breakers for external dependencies
- Load testing scenarios
This project reflects real-world backend engineering practices:
- Distributed systems design
- Event-driven architecture
- Data consistency strategies
- Observability and tracing
- High reliability patterns used in production systems
Marcos Tadeu Silva
Senior Backend Engineer — Distributed Systems | Kafka | AWS
Modern systems demand resilience, scalability, and observability.
This project demonstrates how to design and implement production-grade distributed systems, applying patterns used by high-scale companies.