Mehmet Ozkaya: A Student's Guide to Learning .NET Microservices

If you want to learn how to build microservices in .NET, you will meet Mehmet Ozkaya very fast. He is one of the most practical microservices teachers in the .NET world. This guide explains who he is, what he makes, and how to learn from him step by step without getting lost.

Think of him like a model-train kit master

Imagine you want to learn how a real train network works. You could read a thick book about signals, tracks, and timetables. Or you could buy a giant model-train kit that already has working tracks, real signals, and little trains that actually move. You build it, run it, break it, and fix it. By the end, you get how a real network works because you touched a real one.

Mehmet teaches like that second way. He does not just talk about microservices. He hands you a full, working microservices app that you can download, run on your own computer, and take apart piece by piece. You learn by playing with a real system, not by staring at slides.

That is what makes him special. He is hands-on. His lessons end with real code you can run, not just diagrams you have to imagine.

Who is Mehmet Ozkaya?

Mehmet is a software and solutions architect with 15+ years of experience. He builds cloud-native, event-driven microservices on .NET, on both AWS and Azure. He has worked at companies like Ericsson and Turk Telekom, so he knows big, real systems, not just toy demos.

Today he is best known as a Udemy instructor and a busy open-source author. He shares full reference apps on GitHub at github.com/mehmetozkaya and writes on Medium at mehmetozkaya.medium.com.

He teaches the topics that turn a developer who can build one API into someone who can design a whole system:

• Microservices on .NET
• Domain-Driven Design (DDD)
• CQRS (splitting reads and writes)
• Event-driven architecture with RabbitMQ and MassTransit
• gRPC for fast service-to-service calls
• YARP API gateway, Docker, Redis, Kubernetes
• And newer topics like GenAI

Everything stays grounded in apps you can actually run.

A quick map of who he is

Every resource he offers

Mehmet does not have just one thing. He has paid courses, free reference apps, and free articles. Here they all are in one table.

Let's look at the most important ones a little closer.

The free GitHub reference apps

This is his best free resource. His EShopMicroservices repo and the aspnetrun repos (like run-aspnetcore-microservices) hold full, runnable microservices apps. Across his repos he has gathered 3000+ stars, which is the GitHub way of people saying "this is useful."

These apps are not tiny demos. They include real services: a Catalog service, a Basket service, a Discount service, and an Ordering service. They talk to each other over RabbitMQ, use databases like PostgreSQL, MongoDB, and Redis, and sit behind a YARP API gateway. You can clone the repo, run docker compose up, and watch a real system come alive.

The Udemy courses

When you want a guided tour, his courses walk you through it:

• .NET 8 Microservices: DDD, CQRS, Vertical/Clean Architecture builds the e-commerce app from scratch. You learn ASP.NET Web API, gRPC, RabbitMQ, MassTransit, YARP, Marten, EF Core, CQRS, and DDD by doing.
• Design Microservices Architecture with Patterns & Principles is more about thinking. It evolves a system step by step: monolith, 3-tier, modular monolith, microservices, then event-driven microservices. It covers patterns like API Gateway, BFF, CQRS, Event Sourcing, SAGA, Outbox, CDC, Sidecar, Retry, and Circuit Breaker. It has a 4.4 rating from thousands of students.
• A gRPC microservices course focuses just on gRPC for fast internal calls.

These cost money, but Udemy runs frequent sales, so they are often cheap.

The Medium articles

His writing is free. On mehmetozkaya.medium.com and the aspnetrun publication he explains microservices ideas in words and pictures. These pair nicely with our own guides, like What Is a Modular Monolith? and Migrating a Modular Monolith to Microservices in .NET.

A learning path: from monolith to microservices

Here is the big idea behind everything Mehmet teaches: you do not start with microservices. You start simple and grow. Jumping straight to microservices is like trying to run a busy airport before you have ever run a single bus stop. His own design course follows this exact climb.

Here is the same path explained in words, using his materials:

1. Start with a monolith. One app, one database. Simple and easy. Read our What Is a Modular Monolith? guide to see the next step.
2. Split into modules. Keep one app, but draw clear lines inside it. This is the modular monolith. It is the safest place to learn boundaries.
3. Pull out services. When a module needs its own database and its own team, pull it out into a real microservice. Our Migrating a Modular Monolith to Microservices article walks through this.
4. Go event-driven. Stop making services call each other directly all the time. Instead, let them send messages through RabbitMQ. This is where the Outbox pattern keeps your messages safe.
5. Use Mehmet's app as your reference. At every step, look at how his EShopMicroservices repo does it. Real code beats a thousand words.

This order matters. Many people rush to microservices first and create a giant mess. Mehmet teaches you to earn microservices by understanding the simpler steps first.

How a request flows in his apps

When you run his EShopMicroservices app, a single click on "buy" travels through many small services. Here is the rough journey.

Notice the gateway in front. It is like the front desk of a hotel: every guest talks to the front desk, and the desk sends them to the right room. Notice also the message bus (RabbitMQ): services do not shout at each other directly, they drop notes in a shared mailbox.

Small examples of ideas he is known for

Talking about patterns is fine, but code makes them real. Here are tiny versions of two ideas Mehmet teaches a lot. They are simplified so a beginner can follow.

A CQRS command and handler

CQRS is a fancy name for a simple idea: keep the code that changes data separate from the code that reads data. A "command" is a request to change something. A "handler" is the worker that does it.

Think of a restaurant. The order ticket is the command. The cook who makes the dish is the handler. The ticket does not cook. The cook does not write tickets. Each has one job.

Here is a tiny command and its handler, the style you see all over his Ordering service:

// The "order ticket": just the data needed to do the job.
public record CreateOrderCommand(string CustomerId, decimal Total);
 
// What we hand back when the job is done.
public record CreateOrderResult(Guid OrderId);
 
// The "cook": the worker that runs the job.
public class CreateOrderHandler
{
    private readonly IOrderRepository _orders;
 
    public CreateOrderHandler(IOrderRepository orders)
    {
        _orders = orders;
    }
 
    public async Task<CreateOrderResult> Handle(CreateOrderCommand command)
    {
        var order = new Order(command.CustomerId, command.Total);
        await _orders.AddAsync(order);
        return new CreateOrderResult(order.Id);
    }
}

The command holds only data. The handler holds only logic. This keeps each piece small and easy to test. Our CQRS Pattern, the Way It Should Have Been From the Start article goes deeper.

One honest note for 2026: tools like MediatR, MassTransit, and AutoMapper moved to commercial licenses. That means they may cost money for bigger teams now. His older courses use these libraries, and they are still great for learning the patterns. But many teams now hand-write small handlers like the one above, or pin to older free versions, to avoid the license. The pattern is what matters, not the brand of the library.

A minimal gRPC service

In his apps, the Basket service asks the Discount service "what is the price cut for this item?" It does this with gRPC, which is a fast way for services to talk. gRPC is like two services agreeing on a strict, shared contract before they ever speak, so each call is quick and clear.

You describe the contract in a .proto file:

syntax = "proto3";
 
service DiscountProtoService {
  rpc GetDiscount (GetDiscountRequest) returns (DiscountModel);
}
 
message GetDiscountRequest {
  string productName = 1;
}
 
message DiscountModel {
  string productName = 1;
  int32 amount = 2;
}

Then in C#, your service fills in the logic behind that contract:

public class DiscountService : DiscountProtoService.DiscountProtoServiceBase
{
    private readonly IDiscountRepository _repository;
 
    public DiscountService(IDiscountRepository repository)
    {
        _repository = repository;
    }
 
    public override async Task<DiscountModel> GetDiscount(
        GetDiscountRequest request, ServerCallContext context)
    {
        var discount = await _repository.GetDiscount(request.ProductName);
        return new DiscountModel
        {
            ProductName = discount.ProductName,
            Amount = discount.Amount
        };
    }
}

The Basket service calls GetDiscount like a normal method, but the call travels across the network. That is the magic of gRPC: a remote call that feels local, and runs fast.

How to learn for free from his GitHub

You can learn a huge amount from Mehmet without paying a cent. The trick is to use his GitHub the right way. Here is a simple plan:

1. Clone the repo. Run git clone https://github.com/mehmetozkaya/EShopMicroservices.
2. Make sure Docker is installed. His apps run in containers, so you need Docker Desktop.
3. Spin it up. From the right folder, run docker compose up -d. This starts every service, the databases, and RabbitMQ at once.
4. Open the services. Visit the Swagger pages and click the endpoints. Watch the system respond.
5. Read one service at a time. Do not try to understand everything at once. Start with the Catalog service. It is the simplest. Then move to Basket, then Ordering.
6. Change one thing. Add a field. Break something on purpose. Fix it. You learn ten times more by editing than by reading.
7. Match it to articles. Read his Medium post on a topic, then find that topic in the code, then read our matching guide. Three views of one idea make it stick.

That loop, run then read then tweak, is the fastest free way to learn real microservices.

Who is he a good fit for?

Let's be honest about this. Mehmet's content is not for absolute beginners. His apps have many moving parts. If you have never built an API, you will feel lost.

He is best for:

In short: if you can build a basic API and now you want to learn how many services work together as one system, he is one of the best teachers you can find.

A gentle warning about microservices

One last honest thing. Microservices are powerful, but they are not free. Every service you split off adds network calls, more databases, more deployment, and more things that can break at 3 a.m. For a small app, all of that is overkill, like building a five-lane highway for a quiet village road.

Mehmet himself teaches this balance. That is why his design course starts with a monolith and climbs slowly. The goal is not to use microservices everywhere. The goal is to understand them well enough to know when they help and when a modular monolith is the smarter, simpler choice. Learn the tools, then use good judgment. That judgment is what makes someone an architect.

Quick recap

• Mehmet Ozkaya is a software and solutions architect with 15+ years building cloud-native, event-driven microservices on .NET across AWS and Azure.
• He is a popular Udemy instructor (.NET 8 Microservices with DDD/CQRS, Design Microservices Architecture with Patterns & Principles, and a gRPC course) and a busy open-source author at github.com/mehmetozkaya.
• Free resources: his GitHub reference apps (EShopMicroservices, the aspnetrun repos, 3000+ stars) and his Medium articles.
• He teaches microservices, DDD, CQRS, event-driven architecture (RabbitMQ + MassTransit), gRPC, YARP, Docker, Redis, Kubernetes, and GenAI, always with runnable apps.
• Best for intermediate .NET developers learning microservices from real, runnable example apps.
• Smart path: start free by running his GitHub app, climb from monolith to microservices step by step, and only buy a course once you know his style fits you.
• Remember that MediatR, MassTransit, and AutoMapper are now commercially licensed, but the patterns he teaches work with any library.

References and further reading

• Mehmet Ozkaya on Udemy (instructor profile)
• .NET 8 Microservices: DDD, CQRS, Vertical/Clean Architecture (Udemy)
• Design Microservices Architecture with Patterns & Principles (Udemy)
• mehmetozkaya on GitHub
• EShopMicroservices reference app (GitHub)
• run-aspnetcore-microservices (aspnetrun, GitHub)
• Mehmet Ozkaya on Medium
• Our related guides: What Is a Modular Monolith?, Migrating a Modular Monolith to Microservices in .NET, Implementing the Outbox Pattern, and CQRS Pattern, the Way It Should Have Been From the Start.