Open Source · .NET 8 · RabbitMQ

EventDrivenApp: A Practical Microservices Template for Event-Driven Systems

Built by WizardLabz as a starting-point template and training tool for teams adopting microservices, asynchronous messaging, and service autonomy.

Build microservices that scale with your organization—not just your servers.

EventDrivenApp is an open-source template and training project created by WizardLabz to demonstrate how modern teams can structure a .NET 8 microservices system around asynchronous events. It includes three independently deployable services, message routing through RabbitMQ, and isolated data stores—so teams can learn the core patterns safely, then apply them to real production programs.

View on GitHub Talk to WizardLabz About Your Microservices Roadmap

Why WizardLabz Built This

Most "microservices examples" are either too academic or too production-specific. This template was built as a practical baseline that teams can run in minutes, understand end-to-end, and use as a shared reference while transitioning from monoliths or tightly-coupled systems.

It's intentionally small—three services—so teams can see the architecture clearly, but complete enough to demonstrate the patterns that matter.

What Executives Struggle With (and What This Template Teaches)

When organizations scale, the bottleneck is rarely coding speed—it's coordination:

  • Releases get blocked because "everything depends on everything."

  • Teams step on each other because responsibilities aren't clear.

  • A change in one area breaks another because boundaries are fuzzy.

  • Systems become fragile because they rely on synchronous calls and shared databases.

Event-driven microservices exist to reduce these risks. This template demonstrates the management-friendly outcomes that matter:

  • Separation of concerns through service boundaries

  • Independent deployments to reduce release collisions

  • Team autonomy because services can evolve without "big bang" coordination

  • Resilience through asynchronous messaging instead of tight coupling

What the Template Includes

EventDrivenApp includes three core services that represent a realistic business workflow:

UserService
Creates and manages users
OrderService
Processes orders
NotificationService
Sends emails, reacts to events
RabbitMQ
User DB (PostgreSQL)
Order DB (PostgreSQL)
SMTP4Dev (Test)

Each service runs independently in its own Docker container, communicates through RabbitMQ, and persists to its own PostgreSQL database. This prevents the "shared database = shared coupling" trap and demonstrates how teams can ship safely in parallel.

How Messaging Enables Scale Without Chaos

Instead of services calling each other directly, they communicate by publishing events:

When a user is created:

UserService publishes user.created
OrderService and NotificationService consume it independently.

When an order is created:

OrderService publishes order.created
NotificationService consumes it to notify the user.

From an executive perspective, the key idea is: one team can improve their service without requiring changes or deployment coordination with another team—as long as the event contract stays stable.

Designed for Multi-Team Delivery

This template helps organizations establish the operating model microservices require:

Clear Scope

Each service has minimal, well-defined responsibilities

Team Ownership

Teams can own services end-to-end: delivery, support, iteration

Event Contracts

Interfaces between teams become event contracts, not shared code paths

Realistic Testing

Validate contracts and message flows, not only function calls

This is the foundation for scaling engineering capacity while reducing dependency friction.

How This Reduces Business Risk

EventDrivenApp is small, but it demonstrates patterns that reduce production risk:

Resilience

Message-based workflows tolerate temporary downstream issues better than synchronous chains

Change Isolation

Fewer "company-wide" regressions from localized updates

Deployment Independence

Teams release when they're ready, not when everyone is ready

Operational Clarity

Services have explicit responsibilities and boundaries

Intended Use

This project is designed as:

Starting-Point Template

For new microservices initiatives

Training Tool

For onboarding teams to event-driven thinking

Reference Architecture

For structuring services, messaging, and data isolation in .NET

It is not a complete production product by itself—it's a practical baseline that prevents teams from reinventing patterns incorrectly.

Run It in Minutes

  1. Clone the repo
    git clone https://github.com/amir-magdy-of-wizardlabz/EventDrivenApp.git
  2. Start all services
    docker-compose up --build
  3. Explore flows
    Create user → observe events → create order → observe notifications
GitHub Repository Contact WizardLabz

Next steps for production: hardening with observability, retries, idempotency, dead-letter queues (DLQs), versioning, and distributed tracing.

Built by

WizardLabz builds scalable systems and helps teams adopt architectures that match how organizations grow. If you're moving from a monolith to microservices—or struggling with cross-team release dependencies—we can help you design the boundaries, event contracts, and operational practices that make microservices work.

We provide architecture guidance, execution support, event contract design, migration planning, team boundary design, and operational readiness consulting.

View Our Services Start a Conversation

Download the Executive White Paper (PDF)

Get the complete guide to event-driven microservices for multi-team organizations, including architecture overview, organizational benefits, and adoption guidance.

Executive summary
Reference architecture
Multi-tenant model
Adoption guidance
Download PDF

No email required. Direct download.

Ready to Adopt Event-Driven Microservices?

Whether you're breaking apart a monolith, designing service boundaries, or establishing event contracts for multi-team delivery—we can help you get it right the first time.

Start a Conversation

More Case Studies

Explore how we've helped other businesses build systems that scale.

eCommerce Search Performance Waitwize Virtual Queue View All Case Studies