Projectify

Enterprise-Ready Distributed Project Management Platform
Engineered with Event-Driven Microservices, Polyglot Persistence & Real-Time WebSockets

✨ Try the Live Interactive Demo (Zero Setup Required) →

Live Demo • Architecture • Services • Quickstart • Security • Testing • API Reference

---

🎮 Live Interactive Demo

Experience the full Projectify workspace directly in your browser without spinning up local databases or containers:

💡 Highlights of the Showcase Demo:

• 100% Offline & Client-Side: Powered by an in-memory & localStorage mock adapter replicating Fastify REST endpoints and Socket.IO real-time notification streams.
• 1-Click Instant Login: Log in immediately as Admin (Elena Rostova), Team Lead (Marcus Vance), or Developer (Sarah Chen) directly from the login page.
• Rich Pre-loaded Data: 3 engineering teams, interactive Kanban board with TipTap rich-text descriptions, multi-tag task filtering, and simulated team notifications.

---

🌟 Executive Overview

Projectify is a production-grade, collaborative project and task management system built specifically to demonstrate modern cloud-native architectural patterns. Engineered with Domain-Driven Design (DDD) and Clean Architecture, it decouples transactional authentication, collaborative workspaces, task workflows, and live notifications into independent microservices wired together through an Nginx API Gateway and Redis Pub/Sub event bus.

🎯 Key Architectural Highlights

⚡ Distributed Microservices Four specialized microservices built with Fastify v5 and strict TypeScript. Layered separation: Controllers/Routes → Zod Schemas → Domain Services → Models/Repositories. Independent scaling, isolated fault domains, and per-service health probes (/health).	🔄 Polyglot Persistence PostgreSQL 16 via Prisma 7 for relational integrity and RBAC user state. MongoDB 7 via Mongoose for unstructured documents (teams, kanban tasks, comments). Redis 7 (AOF) for high-throughput Pub/Sub real-time message brokering.
📡 Real-Time Collaborative Engine Instant notifications via Socket.IO with automated room management per user. Cross-service event distribution using non-blocking Redis channels. Live Kanban task updates, assignment alerts, and threaded rich-text comments.	🛡️ Defense-in-Depth Security Nginx Gateway handling SSL termination, rate limiting (10 req/s), and HTTP/2. Per-service rate limiting via @fastify/rate-limit protecting authentication vectors. Non-root multi-stage Docker execution and strict Content Security Policies.

---

🏗️ System Architecture

graph TD
    Client["Client Browser<br/>React 19 + TanStack Query + Tailwind"]
    Gateway["Nginx API Gateway (:80 / :443)<br/>Rate Limiting, Gzip, CSP & Reverse Proxy"]
    
    subgraph Microservices ["Microservices Layer (Fastify v5 + TypeScript)"]
        UserService["User Service (:3001)<br/>JWT Auth, RBAC & Lifecycle"]
        TeamService["Team Service (:3002)<br/>Workspaces, Members & Ownership"]
        TaskService["Task Service (:3003)<br/>Kanban Tasks, Comments & GCS Files"]
        NotifService["Notification Service (:3004)<br/>Socket.IO WebSocket Engine"]
    end
    
    subgraph Storage ["Polyglot Storage & Message Bus Layer"]
        Postgres[(PostgreSQL 16<br/>Prisma Client)]
        Mongo[(MongoDB 7<br/>Teams & Tasks)]
        Redis[(Redis 7<br/>Pub/Sub Event Bus)]
        GCS["Google Cloud Storage<br/>(Task Attachments)"]
    end

    Client -->|HTTP / REST| Gateway
    Client -.->|WebSocket / Socket.IO| Gateway
    
    Gateway -->|/api/users| UserService
    Gateway -->|/api/teams| TeamService
    Gateway -->|/api/tasks| TaskService
    Gateway -->|/api/notifications| NotifService
    Gateway -.->|/socket.io/| NotifService

    UserService --> Postgres
    TeamService --> Mongo
    TeamService -->|Publish Events| Redis
    TaskService --> Mongo
    TaskService -->|Publish Events| Redis
    TaskService -.->|Upload/Stream| GCS
    NotifService --> Mongo
    Redis -->|Subscribe Events| NotifService

Loading

---

📦 Microservices Breakdown

Service	Port	Runtime / Framework	Data Store	Core Responsibilities
User Service	3001	Node.js 20+ • Fastify v5 • TypeScript	PostgreSQL 16 (Prisma 7)	Authentication, JWT signing, password hashing (bcrypt), RBAC administration, account approval.
Team Service	3002	Node.js 20+ • Fastify v5 • TypeScript	MongoDB 7 (Mongoose)	Team creation, membership management, leadership delegation, Redis event publication.
Task Service	3003	Node.js 20+ • Fastify v5 • TypeScript	MongoDB 7 (Mongoose)	Kanban tasks (TODO/IN_PROGRESS/DONE), multi-assignee tracking, rich text comments, file attachments (local/GCS).
Notification Service	3004	Node.js 20+ • Fastify v5 • TypeScript	MongoDB 7 • Redis 7	Socket.IO server, Redis subscriber, persistent notification logging, unread badge counters.
Frontend	80	React 19 • Vite 7 • TypeScript	Local / Browser State	Kanban boards, real-time toast alerts, TipTap editor, Recharts analytics, responsive DaisyUI layout.
API Gateway	80 / 443	Nginx Alpine	N/A	Reverse proxy, SSL termination, request throttling, gzip compression, security headers.

---

🚀 Quickstart & Local Setup

Prerequisites

• Docker & Docker Compose
• Node.js v20+ (optional, for local development outside Docker)

1. Launch the Stack

Clone the repository and start all containers with Docker Compose:

# Clone the repository
git clone https://github.com/Brilliafy/Projectify.git
cd Projectify

# Spin up databases, services, gateway, and frontend
docker compose up -d --build

All microservices will self-heal and wait for database health checks before starting:

• Web Application: http://localhost
• User Service Health: http://localhost/api/users/health
• Team Service Health: http://localhost/api/teams/health
• Task Service Health: http://localhost/api/tasks/health
• Notification Service Health: http://localhost/api/notifications/health

2. Seed Initial Administrator Account

New user registrations are set to inactive by default until approved by an administrator. Seed the default admin user:

# Run database seed script inside the user-service
docker compose exec user-service node create-admin.js

Default Credentials: admin@projectify.com / admin123 (Promptly change password in production)

---

🛡️ Security & Defense-in-Depth

[ Internet Traffic ]
        │
        ▼
[ Nginx Gateway ] ──► SSL/TLS (Let's Encrypt), Rate-Limit (10 req/s), CSP, HSTS, X-Frame-Options
        │
        ▼
[ Microservice App Layer ] ──► In-Process @fastify/rate-limit, CORS, JWT Verification, Non-Root Containers
        │
        ▼
[ Data Layer ] ──► Parameterized Prisma / Mongoose Queries, Bcrypt Hashing (10 Rounds), Internal Docker Network

1. API Gateway Rate Limiting: Throttles DDoS and aggressive scraping using Nginx's limit_req_zone with burst cushioning.
2. Endpoint Brute-Force Protection: Sensitive authentication routes (/api/users/login) employ strict in-process rate limiting via @fastify/rate-limit.
3. Hardened HTTP Headers: Strict Content-Security-Policy, X-Content-Type-Options: nosniff, X-Frame-Options: DENY, and HSTS.
4. Least-Privilege Containers: Multi-stage Docker builds run unprivileged users (USER node / USER nginx).
5. No Secret Leaks: Configuration is completely driven by environment variables (.env.example provided; .env excluded from version control).

---

🧪 Testing & Quality Assurance

Projectify features an automated, zero-external-dependency test harness built on Node's native node:test and node:assert modules, orchestrated via tsx --test.

By leveraging Fastify's in-memory server.inject() mechanism, tests validate HTTP routes, authentication guards, role-based permissions, and schema rejections in under 2 seconds without requiring live database connections.

# Run tests for all individual microservices
(cd user-service && npm test)
(cd team-service && npm test)
(cd task-service && npm test)
(cd notification-service && npm test)

# Lint and verify frontend build
(cd frontend && npm run lint)
(cd frontend && npm run build)

Continuous Integration (CI)

A multi-job GitHub Actions workflow (.github/workflows/ci.yml) runs on every push and PR:

• Strict TypeScript compile check across all workspaces.
• ESLint verification with zero warnings.
• Complete execution of all microservice test suites.

---

📖 API Reference

All requests pass through the Nginx gateway and require a Bearer JWT token in the Authorization header (except public auth routes).

🔐 User Service (/api/users)

Method	Endpoint	Access	Description
POST	/api/users/register	Public	Register new account (pending admin approval)
POST	/api/users/login	Public	Authenticate credentials & receive JWT
GET	/api/users	Authenticated	List all active users for mention/assignment
GET	/api/users/admin	Admin	Retrieve all registered users with activation state
PATCH	/api/users/admin/:id/activate	Admin	Activate a pending user account
PATCH	/api/users/admin/:id/role	Admin	Update user role (ADMIN, TEAM_LEADER, MEMBER)
DELETE	/api/users/admin/:id	Admin	Delete a user account (with last-admin protection)

👥 Team Service (/api/teams)

Method	Endpoint	Access	Description
GET	/api/teams/mine	Authenticated	Fetch teams where the user is a member
GET	/api/teams/owned	Authenticated	Fetch teams where the user is the leader
GET	/api/teams	Admin	Fetch all teams across the system
POST	/api/teams	Team Leader / Admin	Create a new team workspace
POST	/api/teams/:id/members	Team Leader / Admin	Add a registered member to the team
DELETE	/api/teams/:id/members/:userId	Team Leader / Admin	Remove a member from the team

📋 Task Service (/api/tasks)

Method	Endpoint	Access	Description
GET	/api/tasks	Authenticated	Fetch tasks (supports teamId query filtering)
POST	/api/tasks	Team Leader / Admin	Create task with multipart attachment uploads
PATCH	/api/tasks/:id/status	Authenticated	Update task stage (TODO, IN_PROGRESS, DONE)
PATCH	/api/tasks/:id	Team Leader / Admin	Update title, description, deadline, or priority
POST	/api/tasks/:id/comments	Authenticated	Post rich-text comment with mention support
GET	/api/tasks/:id/comments	Authenticated	Fetch chronological comments for a task

🔔 Notification Service (/api/notifications)

Method	Endpoint	Access	Description
GET	/api/notifications	Authenticated	Fetch the latest 50 notifications for user
PATCH	/api/notifications/:id/read	Authenticated	Mark an individual notification as read
PATCH	/api/notifications/read-all	Authenticated	Mark all notifications as read
DELETE	/api/notifications	Authenticated	Clear user's notification history

---

☁️ Google Cloud Platform Deployment

Projectify includes production configuration for Google Compute Engine (GCE):

• Virtual Machine: Debian 12 (Bookworm) on an e2-medium instance.
• Object Storage: Google Cloud Storage (GCS) for resilient, scalable attachment hosting.
• IAM Principle of Least Privilege: Custom service account scoped strictly to Storage Object Admin and Logging Agent.
• Automated Provisioning: Deployable via root shell script with UFW firewall configuration.

---

📄 License

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