Skip to main content

Enterprise Event Ticketing Platform

Build scalable ticketing systems with microservices architecture, CQRS, and event-driven design. Distributed reservations, real-time inventory, and high-availability seat management out of the box.

Get StartedExplore Architecture

Quick Start

Get the platform running in minutes and complete your first ticket purchase workflow.

1

Start the infrastructure

Launch all microservices, Kafka, PostgreSQL, and Redis with Docker Compose:
cd infra
docker compose up -d
All services will start with health checks. Wait approximately 30 seconds for initialization.
2

Verify services are healthy

Check that all services respond to health endpoints:
curl http://localhost:50001/health  # Catalog
curl http://localhost:50002/health  # Inventory
curl http://localhost:5003/health   # Ordering

{
  "status": "Healthy",
  "service": "Catalog"
}
3

Make your first reservation

Reserve a seat using the Inventory service:
curl -X POST http://localhost:50002/reservations \
  -H "Content-Type: application/json" \
  -d '{
    "seatId": "550e8400-e29b-41d4-a716-446655440002",
    "customerId": "user-123"
  }'
The reservation will be held for 30 minutes with distributed Redis locks.
4

Add to cart and checkout

After waiting 2-3 seconds for the Kafka event to propagate, add the seat to your cart:
curl -X POST http://localhost:5003/cart/add \
  -H "Content-Type: application/json" \
  -d '{
    "reservationId": "<reservation-id-from-step-3>",
    "seatId": "550e8400-e29b-41d4-a716-446655440002",
    "price": 50.00,
    "userId": "user-123"
  }'
Then complete checkout to trigger the payment and fulfillment pipeline. See the Frontend Integration Guide for complete E2E workflow details.

Explore by Topic

Dive into the architecture patterns and services that power the platform.

Architecture

Understand the hexagonal architecture, bounded contexts, and service communication patterns.

Microservices

Explore the seven microservices: Catalog, Inventory, Ordering, Payment, Fulfillment, Notification, and Identity.

Event-Driven Design

Learn how Kafka orchestrates reservation workflows and asynchronous ticket fulfillment.

CQRS Pattern

Separate read and write models with MediatR and optimize for high-concurrency seat selection.

Distributed Locks

Prevent double-booking with Redis-based distributed locks and TTL-based reservation expiration.

API Reference

Complete REST API documentation for all services with request/response schemas and error codes.

Services

Each service is independently deployable and follows clean architecture principles.

Catalog Service

Manages events, venues, and seat maps. Provides read-optimized queries for event discovery.

Inventory Service

Handles seat reservations with Redis locks. Publishes reservation-created events to Kafka.

Ordering Service

Manages shopping carts and order lifecycle. Consumes reservation events and triggers payments.

Payment Service

Processes payments and publishes success/failure events. Integrates with payment gateways.

Fulfillment Service

Generates tickets after successful payment. Stores ticket PDFs and sends to customers.

Notification Service

Sends email and SMS notifications for order confirmations and ticket delivery.

Deployment & Operations

Production-ready deployment guides and operational best practices.

Deployment Guide

Deploy to Docker, Kubernetes, or cloud platforms with infrastructure-as-code templates.

Testing Strategy

Unit tests, integration tests, and ATDD workflows with xUnit and Docker Compose.

Kafka Events

Event schemas, topic configuration, and consumer patterns for asynchronous workflows.

Frontend Integration

Complete guide for integrating with the Next.js frontend and handling reservation flows.

Ready to build?

Start with our quickstart guide and have a working ticketing platform running in under 5 minutes.

Get Started Now