💬 Real-Time Chat App

Distributed Messaging Platform · Go · Microservices · WebSockets

A production-inspired distributed real-time messaging backend — 6 independent Go microservices communicating through WebSockets, Redis Pub/Sub, and Kafka. Built to demonstrate strong system design and backend engineering skills.

---

✨ Highlights

• 🏗️ 6 Independent Microservices — each fault-isolated with its own DB connection, config, and entry point
• 📡 WebSocket Real-Time Delivery — persistent bi-directional connections for instant messaging
• ⚡ Redis Pub/Sub — low-latency message fan-out across service instances
• 📨 Kafka Event Streaming — durable async processing, guaranteed message delivery
• 💾 MongoDB — flexible document storage for chats and messages
• 🔐 JWT Authentication — access + refresh token flow across all services
• 🐳 Fully Dockerized — all 6 services + infrastructure via Docker Compose
• 🧱 Clean Architecture — handler → service → repository layering in every service

---

🏗️ Architecture

                        ┌─────────────────┐
                        │   API Gateway   │
                        └────────┬────────┘
                                 │
          ┌──────────────────────┼──────────────────────┐
          │                      │                      │
   ┌──────▼──────┐      ┌────────▼───────┐    ┌────────▼───────┐
   │ Auth Service│      │  User Service  │    │  Chat Service  │
   │ JWT tokens  │      │ Profile mgmt   │    │ Groups/1-on-1  │
   └─────────────┘      └────────────────┘    └────────────────┘

   ┌─────────────┐      ┌────────────────┐    ┌────────────────┐
   │  Message    │      │  Notification  │    │   WebSocket    │
   │  Service   │      │    Service     │    │    Service     │
   │ Send/Edit  │      │ Kafka-driven   │    │ Real-time hub  │
   └──────┬──────┘      └───────┬────────┘    └───────┬────────┘
          │                     │                     │
          └─────────────────────┼─────────────────────┘
                                │
              ┌─────────────────┼─────────────────┐
              │                 │                 │
       ┌──────▼──────┐  ┌───────▼──────┐  ┌──────▼──────┐
       │   MongoDB   │  │    Kafka     │  │    Redis    │
       │  Messages   │  │   Events     │  │   Pub/Sub   │
       └─────────────┘  └──────────────┘  └─────────────┘

Message Flow

Client → WebSocket Service → Redis Pub/Sub → Kafka → Message Service → MongoDB → Broadcast

---

🛠️ Tech Stack

Layer	Technology
Language	Go 1.21+
HTTP Framework	Fiber
Real-Time	WebSockets (gorilla/websocket)
Event Streaming	Kafka
Pub/Sub	Redis
Database	MongoDB
Authentication	JWT (access + refresh tokens)
Containerization	Docker + Docker Compose

---

🔧 Services

🔐 Auth Service

• User registration and login
• JWT access token + refresh token issuance
• Token validation middleware

👤 User Service

• Fetch and update user profile
• Delete account
• User search

💬 Chat Service

• Create 1-on-1 chats
• Create and manage group chats
• Add/remove group members

📨 Message Service

• Send, receive, edit, delete messages
• Mark messages as read
• Message history with pagination

🔔 Notification Service

• Kafka-driven async notification processing
• User notification delivery
• Event-based triggers

🌐 WebSocket Service

• Maintains persistent WebSocket connections
• Publishes events to Redis Pub/Sub for real-time fan-out
• Forwards durable message events to Kafka

---

📁 Project Structure

chat-app/
├── backend/
│   ├── api-gateway/              # Request routing
│   └── services/
│       ├── auth-service/
│       │   ├── cmd/              # Entry point
│       │   ├── internal/         # Handler · Service · Repository
│       │   ├── configs/          # Environment config
│       │   └── .env.example
│       ├── user-service/
│       ├── chat-service/
│       ├── message-service/
│       ├── notification-service/
│       └── websocket-service/
├── docs/                         # Architecture diagrams
├── postman/                      # API collection
├── docker-compose.yaml           # Full stack orchestration
└── dockerfile

Each service follows Clean Architecture:

cmd/         → entry point, dependency wiring
internal/    → handler → service → repository
configs/     → environment-based config

---

🚀 Getting Started

Prerequisites

• Go 1.21+
• Docker & Docker Compose

1. Clone the repo

git clone https://github.com/fathimasithara01/chat-app.git
cd chat-app/backend

2. Configure environment

# For each service
cp services/auth-service/.env.example services/auth-service/.env
cp services/user-service/.env.example services/user-service/.env
# ... repeat for other services

3. Start all services

docker-compose up --build

This starts all 6 microservices + MongoDB + Redis + Kafka together.

---

📡 API Endpoints

Auth Service

Method	Path	Description
POST	/auth/register	Register new user
POST	/auth/login	Login — returns JWT pair
POST	/auth/refresh	Refresh access token
POST	/auth/logout	Logout

User Service

Method	Path	Description
GET	/users/:id	Get user profile
PATCH	/users/:id	Update profile
DELETE	/users/:id	Delete account

Chat Service

Method	Path	Description
POST	/chats	Create 1-on-1 chat
POST	/chats/group	Create group chat
PATCH	/chats/:id/members	Add/remove members
GET	/chats	List user's chats

Message Service

Method	Path	Description
POST	/messages	Send message
GET	/messages/:chatId	Get message history
PATCH	/messages/:id	Edit message
DELETE	/messages/:id	Delete message

WebSocket

ws://localhost:PORT/ws?token=<jwt>

---

🔑 Key Design Decisions

Why Redis Pub/Sub + Kafka together? Redis handles low-latency real-time fan-out — messages reach online users instantly. Kafka provides durability — events are persisted and processed asynchronously even if a service is temporarily down.

Why separate WebSocket service? Isolating WebSocket connections in their own service means connection state is independent of business logic. Other services simply publish to Redis — they don't need to know which users are connected.

Why Fiber? Fiber's fasthttp foundation handles high concurrency well — important for a chat backend where many connections are open simultaneously.

---

📬 Postman Collection

Import postman/ collection into Postman to test all services. Set base_url per service and use Auth endpoints to get your JWT token automatically.

---

👩‍💻 Author

Fathima Sithara — Backend Engineer (Go · Distributed Systems)

Also check out:

• 🏦 MultiTrade Platform — Production-grade trading backend in Go
• 🛒 E-Commerce Platform — Next.js + Node.js full-stack app

---

⭐ If this project helped you, please give it a star!