All Projects
BookStore Microservices Architecture

BookStore Microservices Architecture

Client

Open Source

Services:

System Architecture, API Development, and Deployment

Github Repository

BookStore Microservices Architecture is a full-stack open-source system that demonstrates modern backend development using microservices. Built entirely solo, the project features modular services for authentication (Django), catalog management (Flask), order handling (Node.js), and a Go-based API Gateway. These services communicate asynchronously using RabbitMQ and are fully containerized with Docker, deployed via Kubernetes.

Service-Oriented Design: Each microservice is independently developed, allowing scalable and maintainable architecture.
Message Queue Integration: RabbitMQ enables real-time updates between order and catalog services.
Containerization and Orchestration: Docker and Kubernetes streamline development, deployment, and scaling in a cloud environment.

The Challenge

Build a backend that stays reliable as it grows — where each part can be developed, deployed, and scaled independently, and where one slow or failing component never takes down the whole system. This open-source project is a working demonstration of exactly how I approach scalable, fault-tolerant backend architecture.

What I Built

Instead of one large monolith, I split the system into focused microservices — each written in the language best suited to its job — coordinated by a custom API gateway and an asynchronous message broker.

  • Authentication — Django + JWT: secure registration, login, and stateless token-based auth with access and refresh tokens.
  • Catalog — Flask: a lightweight service for books and inventory that updates stock by reacting to order events.
  • Orders — Node.js: handles order placement and status, publishing events like "order placed" to the broker.
  • API Gateway — Go: a single, fast entry point that routes requests, validates JWTs, and shields the internal services from the outside world.
  • RabbitMQ: asynchronous pub/sub messaging so services stay decoupled — an order updates the catalog without the two ever calling each other directly.

Why it's built this way: each service can scale or be rebuilt on its own, the asynchronous messaging keeps the system resilient (events wait safely in the queue if a service is briefly down), and the Go gateway keeps everything secure behind one controlled entry point.

Shipping It to Production

Every service is packaged as its own Docker container and deployed on Kubernetes — with Deployments managing pods, Services handling internal and external access, and Secrets & ConfigMaps for secure, flexible configuration. High-load services like Orders or the Gateway can scale horizontally without touching the rest, which is the whole point of the design.

The Outcome

A fault-tolerant, cloud-native backend where any service can scale or fail independently without bringing down the others — a working blueprint for the kind of resilient, production-grade systems I build for clients. The full source is available on GitHub.

Tech Stack

LayerTechnology
AuthenticationDjango + DRF + JWT
CatalogFlask
OrdersNode.js + Express
API GatewayGolang
MessagingRabbitMQ
ContainerizationDocker
OrchestrationKubernetes