explaingit

microservices-patterns/ftgo-application

3,703JavaAudience · developerComplexity · 5/5Setup · hard

TLDR

FTGO is the companion code for the book Microservice Patterns, showing a Java food-delivery app split into microservices that communicate over Kafka using sagas, event sourcing, and CQRS.

Mindmap

mindmap
  root((repo))
    What it does
      Microservice example
      Saga coordination
      Event sourcing CQRS
    Tech stack
      Java Spring Boot
      Apache Kafka
      Docker Kubernetes
    Use cases
      Learn microservices
      Study saga patterns
      Book companion code
    Audience
      Backend developers
      Architects
Click or tap to explore — scroll the page freely

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

Things people build with this

USE CASE 1

Study how sagas coordinate transactions across multiple microservices without a shared database

USE CASE 2

See a working example of CQRS and event sourcing in a Java Spring Boot application

USE CASE 3

Run a multi-service Docker Compose setup to learn how microservices communicate via Kafka

Tech stack

JavaSpring BootApache KafkaDockerKubernetesGradle

Getting it running

Difficulty · hard Time to first run · 1h+

Requires Docker and at least 16 GB of RAM to run all services together, documentation is sparse and relies on the companion book.

In plain English

The FTGO application is the example codebase that accompanies the book Microservice Patterns by Chris Richardson. FTGO stands for Food to Go, a fictional food delivery service. The codebase exists to demonstrate the architectural patterns described in the book rather than to be a production system, so the business logic is intentionally minimal and the documentation points readers to the book for explanations. The application is split into several independent services: one for consumers, one for restaurants, one for orders, one for the kitchen, one for accounting, and one for order history. There is also an API gateway that serves as the single entry point for outside clients. Each service is a separate Spring Boot application with its own Gradle build module and its own Swagger UI for exploring its API. Services communicate in two ways. They expose REST APIs for direct HTTP calls, and they also exchange messages through Apache Kafka using a framework called Eventuate Tram. The order service in particular uses a pattern called sagas to keep data consistent across services without a shared database. Sagas coordinate multi-step operations by exchanging messages between services, so if one step fails the system can compensate. The application uses Docker containers and can be run locally using Docker Compose or deployed to Kubernetes. It requires significant resources: the README recommends a machine with at least 16 GB of RAM to run all the services together. This codebase is most useful as a learning resource for developers reading the Microservice Patterns book who want to see saga patterns, event sourcing, and CQRS working in real code.

Copy-paste prompts

Prompt 1
How does the FTGO order service implement sagas to keep data consistent across microservices?
Prompt 2
Walk me through the FTGO codebase structure so I understand which service does what
Prompt 3
How do I run the FTGO application locally with Docker Compose and explore the Swagger UIs?
Prompt 4
Show me how Eventuate Tram is used in FTGO to send and receive messages between services over Kafka
Open on GitHub → Explain another repo

← microservices-patterns on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.