💬 Chatify - Enterprise-Grade Real-Time Chat Platform

Production-Ready • Scalable • Secure

Documentation • Architecture • API Docs • VPS Deployment Guide

🎯 Project Overview

Chatify is a production-ready, enterprise-grade real-time chat application built with modern technologies and best practices. This project demonstrates proficiency in full-stack development, microservices architecture, security implementation, and DevOps practices.

Built to impress: This isn't just another chat app—it's a showcase of production-ready engineering with security, scalability, and deployment automation at its core.

✨ What Makes This Special

🏗️ Production-Ready Architecture - Microservices design with Docker containerization
🔐 Security-First - JWT authentication, encrypted credentials, HTTPS/SSL ready
🚀 Real-Time Performance - WebSocket-based instant messaging with STOMP protocol
📊 Observability - Health checks, metrics, and monitoring endpoints
🔄 DevOps Ready - Automated deployment, backup scripts, CI/CD compatible
🎨 Modern UI/UX - Responsive Vue 3 frontend with TailwindCSS

🛠️ Tech Stack

Backend

Frontend

DevOps & Infrastructure

🏗️ Architecture

graph TB
    Client[Client Browser] -->|HTTPS| Nginx[Nginx Reverse Proxy]
    Nginx -->|/api/*| Backend[Spring Boot Backend]
    Nginx -->|/ws| Backend
    Nginx -->|/| Frontend[Vue 3 SPA]
    Backend -->|CRUD Operations| MongoDB[(MongoDB)]
    Backend -->|WebSocket| Client
    
    subgraph "Docker Network"
        Nginx
        Backend
        MongoDB
        Frontend
    end
    
    style Client fill:#4FC08D
    style Nginx fill:#009639
    style Backend fill:#6DB33F
    style Frontend fill:#4FC08D
    style MongoDB fill:#47A248

Key Design Decisions:

Microservices Architecture - Independently scalable services
Reverse Proxy Pattern - Nginx for SSL termination and load balancing
Stateless Backend - JWT tokens for horizontal scalability
Container Orchestration - Docker Compose for easy deployment

See ARCHITECTURE.md for detailed design documentation.

🚀 Features

Core Functionality

✅ Real-Time Messaging - Instant message delivery via WebSockets
✅ User Authentication - Secure JWT-based auth with refresh tokens
✅ Persistent Chat History - MongoDB-backed message storage
✅ Online Status - Live user presence tracking
✅ Multiple Chat Rooms - Support for one-on-one conversations
✅ Responsive Design - Mobile-first UI that works everywhere

Security Features 🔐

✅ JWT Authentication - Secure token-based authentication
✅ Password Hashing - BCrypt password encryption
✅ HTTPS/TLS Ready - SSL certificate configuration included
✅ CORS Protection - Configurable cross-origin resource sharing
✅ Security Headers - XSS, CSP, HSTS headers configured
✅ Environment Variables - Secrets externalized and protected
✅ Input Validation - Server-side validation on all endpoints

DevOps & Operations 🔧

✅ Docker Containerization - Multi-stage builds for optimization
✅ Health Checks - Automated container health monitoring
✅ Automated Backups - Scheduled MongoDB backup scripts
✅ Monitoring Endpoints - Spring Boot Actuator integration
✅ Log Management - Structured logging with configurable levels
✅ One-Command Deployment - Automated deployment scripts
✅ Security Validation - Pre-deployment security checks

Code Quality 📊

✅ Clean Architecture - Separation of concerns, layered design
✅ RESTful API - Standard HTTP methods and status codes
✅ Error Handling - Comprehensive exception handling
✅ Unit Tests - JUnit tests for critical components
✅ API Documentation - OpenAPI/Swagger integration
✅ Type Safety - TypeScript-like structure with Pinia stores

📸 Screenshots

Login & Registration

Chat Interface

Real-Time Messaging Demo

⚡ Quick Start

Prerequisites

Docker & Docker Compose installed
2GB+ RAM available
Ports 3000 and 4000 available

Installation

# 1. Clone the repository
git clone https://github.com/YOUR_USERNAME/chatify.git
cd chatify

# 2. Configure environment variables
cp .env.example .env

# Edit .env and set secure credentials
# Generate secure values:
# MongoDB password: openssl rand -base64 32
# JWT secret: openssl rand -base64 64
nano .env

# 3. Validate security configuration
./validate-security.sh

# 4. Deploy with Docker
./deploy.sh

# 5. Verify deployment
curl http://localhost:4000/actuator/health

Access the application:

Frontend: http://localhost:3000
Backend API: http://localhost:4000
Health Check: http://localhost:4000/actuator/health

📚 Documentation

Document	Description
DEPLOYMENT.md	Complete deployment guide with Docker
VPS_DEPLOYMENT_GUIDE.md	Step-by-step VPS deployment with HTTPS
ARCHITECTURE.md	System architecture and design decisions
API_DOCS.md	REST API endpoint documentation
CONTRIBUTING.md	Contribution guidelines

🔐 Security

Security is a top priority. This project implements:

Authentication: JWT with access & refresh tokens
Encryption: BCrypt password hashing, HTTPS/TLS support
Secrets Management: Environment variables, never committed to Git
Input Validation: Server-side validation on all inputs
Security Headers: XSS protection, CSP, HSTS, frame options
Database Security: MongoDB authentication, internal network only
Container Security: Non-root users, minimal attack surface

Security Validation: Run ./validate-security.sh before deployment to catch common security issues.

🚀 Deployment

Local Development

# Backend (Spring Boot)
cd server
mvn spring-boot:run

# Frontend (Vue 3)
cd client
npm install
npm run dev

Production Deployment (Docker)

# One-command deployment
./deploy.sh

# Or manually
docker compose up -d --build

VPS Deployment

Complete guide with HTTPS/SSL setup available in VPS_DEPLOYMENT_GUIDE.md

Includes:

Ubuntu server setup
Docker installation
SSL certificate (Let's Encrypt)
Automated backups
Firewall configuration
Monitoring setup

📊 Performance & Metrics

Build Time: ~49 seconds (multi-stage Docker build)
Startup Time: ~60 seconds (all services)
Container Size:
- Backend: ~250MB (Alpine-based JRE)
- Frontend: ~45MB (Nginx Alpine)
- MongoDB: ~700MB
Response Time: <100ms (REST API)
WebSocket Latency: <50ms (real-time messaging)
Memory Usage: ~500MB (all containers combined)

🧪 Testing

# Run backend tests
cd server
mvn test

# Run frontend tests (if configured)
cd client
npm run test

# Security validation
./validate-security.sh

Test Coverage:

Unit tests for core services
Integration tests for API endpoints
Security validation scripts

🤝 Contributing

Contributions are welcome! Please read CONTRIBUTING.md for details on our code of conduct and the process for submitting pull requests.

Fork the repository
Create your feature branch (git checkout -b feature/AmazingFeature)
Commit your changes (git commit -m 'Add some AmazingFeature')
Push to the branch (git push origin feature/AmazingFeature)
Open a Pull Request

📝 API Examples

Register a New User

curl -X POST http://localhost:4000/auth/register \
  -H "Content-Type: application/json" \
  -d '{
    "username": "john_doe",
    "email": "john@example.com",
    "password": "SecurePass123"
  }'

Login

curl -X POST http://localhost:4000/auth/login \
  -H "Content-Type: application/json" \
  -d '{
    "username": "john_doe",
    "password": "SecurePass123"
  }'

Send a Message (WebSocket)

const socket = new SockJS('http://localhost:4000/ws');
const stompClient = Stomp.over(socket);

stompClient.connect({}, () => {
  stompClient.send('/app/chat', {}, JSON.stringify({
    senderId: 'user1',
    receiverId: 'user2',
    content: 'Hello, World!'
  }));
});

Complete API documentation: API_DOCS.md

🎓 What I Learned

Building this project taught me:

Full-Stack Development - End-to-end application development
Real-Time Communication - WebSocket protocol and STOMP
Security Best Practices - JWT, encryption, secure deployment
Microservices Architecture - Service separation and communication
Docker & Containerization - Multi-stage builds, orchestration
DevOps Practices - Automated deployment, monitoring, backups
Production Deployment - VPS setup, SSL, database backups
Modern Frontend - Vue 3 Composition API, state management

💼 Why This Project Stands Out

✅ Production-Ready - Not just a tutorial project, built for real deployment
✅ Security-Conscious - Implements industry-standard security practices
✅ Well-Documented - Extensive documentation for every aspect
✅ Scalable Architecture - Designed to handle growth
✅ DevOps Integration - Automated deployment and monitoring
✅ Clean Code - Follows SOLID principles and best practices
✅ Modern Tech Stack - Latest versions of frameworks and tools

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

👨‍💻 Author

Sreenath Yadav

🙏 Acknowledgments

Spring Boot team for the excellent framework
Vue.js community for the fantastic frontend tools
MongoDB for the flexible database solution
Docker for simplifying deployment
All open-source contributors

⭐ Star this repository if you found it helpful!

Built with ❤️ and a lot of ☕

Report Bug • Request Feature • Discussions

Name		Name	Last commit message	Last commit date
Latest commit History 2 Commits
client		client
docs/screenshots		docs/screenshots
nginx		nginx
server		server
.env.example		.env.example
.gitignore		.gitignore
API_DOCS.md		API_DOCS.md
ARCHITECTURE.md		ARCHITECTURE.md
CONTRIBUTING.md		CONTRIBUTING.md
DEPLOYMENT.md		DEPLOYMENT.md
DOCKER_IMAGE_TRANSFER.md		DOCKER_IMAGE_TRANSFER.md
LICENSE		LICENSE
README.md		README.md
VPS_DEPLOYMENT_GUIDE.md		VPS_DEPLOYMENT_GUIDE.md
deploy.sh		deploy.sh
docker-compose.yml		docker-compose.yml
export-docker-images.sh		export-docker-images.sh
import-docker-images.sh		import-docker-images.sh
local_dev.sh		local_dev.sh
validate-security.sh		validate-security.sh

License

sreenathyadavk/chatify

Folders and files

Latest commit

History

Repository files navigation