Skip to main content
Hello and welcome to this lesson.
My name is Mumshad Mannambeth. In this lesson/article we will explore microservices architecture by using a compact, multi-component sample web application and then deploy that application. This sample is commonly used to demonstrate Docker and microservice patterns (see the linked Docker training below) and is ideal for showing how small services interact via shared infrastructure.
A blue presentation slide with the title "Microservices" on the left. On the right is a circular ring of blue dots like a loading icon, with a small footer showing a presenter's name.
So let’s get started. Overview of the sample application
  • The sample is a voting application that demonstrates a microservices-style stack built from several small components implemented in different languages and platforms.
  • It is intentionally compact so you can focus on deployment, inter-service communication, and operational concerns instead of application complexity.
  • Core features provided by the sample:
    • a web UI to submit votes,
    • a background worker to process votes,
    • a persistent database to store aggregated results, and
    • a web UI to display results.
We’ll use this application to show how an entire stack can be packaged, deployed, and run on container platforms. Learn more: Docker Training Course for the Absolute Beginner Architecture and data flow (high level) Component mapping and responsibilities: How data flows through the system
  1. A user chooses an option in the Voting app (e.g., “cats”).
  2. The Voting app writes the vote into Redis, allowing the front-end to respond quickly without waiting for a database transaction.
  3. The Worker consumes the vote message from Redis, processes it, and increments the corresponding counters in PostgreSQL.
  4. The Results app queries PostgreSQL and displays the updated aggregated totals to users.
This design shows common microservice patterns:
  • Decoupled front-ends and background workers via a messaging/queue layer (Redis).
  • Short-lived, in-memory buffering for responsiveness.
  • A single durable datastore for aggregated state and queries.
Next steps in this lesson
  • Package each component as a container image.
  • Deploy the stack (Redis, PostgreSQL, voting app, worker, results app) to a container platform.
  • Observe and verify end-to-end behavior by voting through the UI and seeing the results update.
This lesson uses a multi-service sample to illustrate microservice patterns: decoupled front-ends, asynchronous processing via Redis, and a persistent datastore for aggregates. Use this stack to practice packaging, deployment, networking, and observability for microservices.
Links and references

Watch Video