Studio 8 Task Manager — Real-Time Workspace

A high-concurrency, real-time collaboration platform combining WhatsApp-style conversational workflows with structured Kanban task management.
Engineered with Go (Golang), Next.js 16 (React 19), PostgreSQL 17, Redis, RabbitMQ, and Docker/Nginx.

Quick Summary & Project Links

• Role: Full-Stack / Go Backend & DevOps Engineer
• Target Domains: Go Backend Engineering · DevOps / Infrastructure · Full-Stack Development
• Live Demo: https://s8.studio8.my.id
• Core Architecture: Hexagonal / Ports & Adapters Architecture + WebSocket Hub Pattern

Project Showcase

1. Unified Workspace & Chat-to-Task Interface

Zoom Figure 1: Main workspace showing real-time 1:1 / group chat with inline task creation, priority rating, and status tagging.

2. Interactive Kanban & Task Lifecycle Management

Zoom Figure 2: Kanban board with fluid drag-and-drop (@dnd-kit), multi-criteria filtering (status, priority 0-4, assignee), and task progress breakdown.

3. Calendar & Timeline Scheduling

Zoom

🏗️ System Architecture & Engineering Highlights

Zoom Zoom

Key Technical Strengths & Domain Highlights

1. Go Backend Engineering

• Hexagonal Architecture (Ports & Adapters): Strict domain isolation separating core entities (domain/), business interfaces (port/), orchestration services (service/), and external drivers (adapter/ for HTTP, WebSocket, PostgreSQL, Redis, RabbitMQ).
• High-Throughput WebSocket Hub: Built a concurrent publish/subscribe WebSocket hub leveraging Go channels (chan *Client, chan *RoomSubscription, chan *BroadcastPayload) and sync.RWMutex to handle concurrent connections, room dispatching, and automated dead-client pruning.
• Type-Safe High-Performance SQL (sqlc + pgx/v5): Avoided slow reflection-heavy ORMs by generating compile-time Go code directly from raw PostgreSQL queries, backed by pgxpool connection pooling.
• Robust Auth & RBAC Middleware: JWT authentication with access/refresh token rotation, bcrypt password hashing, Google OAuth2 integration, and role-based route guards.
• Structured Database Migrations: Programmatic Go-driven migration engine (db/migration/) executing incremental schema migrations with transaction safety.

2. DevOps & Infrastructure

• Optimized Multi-Stage Docker Builds:
  • Multi-stage build (golang:1.25-alpine -> alpine:latest).
  • Binary compilation optimized with CGO_ENABLED=0 and -ldflags="-w -s" to strip debug tables, resulting in ultra-compact container image sizes (~25MB).
  • Security hardening: non-root user execution (appuser:appgroup).
• Microservices Orchestration via Docker Compose:
  • Integrated orchestration for Go API, PostgreSQL 17, Redis 8.2 (with AOF persistence), and RabbitMQ 3.13.
  • Automated health check conditions (pg_isready, redis-cli ping) ensuring reliable dependency boot order.
  • Persistent named volumes for zero data loss on service restarts.
• Nginx Reverse Proxy & WebSocket Gateway:
  • Configured reverse proxy to handle Next.js static asset caching (/_next/), dynamic SSR, REST API proxying (/api), and HTTP/1.1 WebSocket upgrades (Upgrade: $http_upgrade, Connection: "upgrade").
  • Configured secure static file routing for /uploads with real client IP forwarding.
• Automated Developer Workflow (Taskfile.yml):
  • Integrated Taskfile recipes for one-command environment startup (task compose:up), schema codegen (task db:gen), and hot-reloading development via air.

3. Full-Stack Development

• Next.js 16 + React 19: Modern App Router paradigm with React Server Components, server actions, client boundaries, and optimized font/asset loading.
• Interactive Drag-and-Drop Kanban: Engineered with @dnd-kit/core and @dnd-kit/sortable, allowing seamless dragging across 15 workflow states with immediate optimistic UI updates and real-time backend synchronization.
• Hybrid Chat & Task Dual State: Real-time chat stream where messages can be promoted to actionable tasks with assigned priority (0–4), status transitions, attachments, and subtask breakdowns.
• PWA (Progressive Web App): Configured web app manifest, service worker lifecycle, responsive viewport design for desktop and mobile devices.

Deep Dive: Real-Time WebSocket Concurrency in Go

WebSocket Hub Architecture

The core messaging engine coordinates rooms and clients concurrently using Go goroutines and channel multiplexing:

Zoom

Figure 3: WebSocket Hub concurrency model with Register, Unregister, JoinRoom, and Broadcast channels.

How Room Joining & Message Broadcasting Works:

1. Client connects to /api/ws/chat?token=<JWT>
2. Hub registers client in user connection pool (Clients[userID][*Client])
3. Client joins room: RoomSubscription dispatched to JoinRoom channel
4. Message sent -> Hub fan-out: broadcasts payload to all active room clients via buffered chan
5. If write fails / client disconnects -> Hub drains dead client from memory to prevent leaks

🗄️ Database Design & Data Dictionary

Relational schema in PostgreSQL 17 modeling Users, Teams, Conversations, Messages, TaskMeta, Subtasks, and Read Receipts.

Key Entities & Data Dictionary

🛠️ Complete Tech Stack Matrix

💡 Engineering Challenges & Solutions

1. Concurrency & Connection Leaks in Real-Time WebSockets

• Problem: In a fast-paced chat and task environment, network dropouts or abrupt client closes can cause dead goroutines, memory leaks, and blocking broadcast channels.
• Solution: Implemented dedicated readPump and writePump per client with pong/ping heartbeats (SetReadDeadline, SetWriteDeadline). Buffered broadcast channels (make(chan *BroadcastPayload, 100)) prevent slow clients from blocking the hub's main select loop, automatically detecting and unregistering broken connections.

2. High Performance Database Querying without ORM Overhead

• Problem: Traditional reflection-based Go ORMs introduce runtime overhead and obscure complex SQL join logic.
• Solution: Adopted sqlc to generate idiomatic, type-safe Go structs and queries directly from raw SQL schema and queries, pairing it with jackc/pgx/v5 connection pooling for maximum database throughput.

3. Dual-Context UI (Chat-Driven Task Management)

• Problem: Users need both real-time WhatsApp-style fast conversation and structured task tracking without switching between disconnected applications.
• Solution: Built a unified data model where any chat message can atomically attach TaskMeta (status, priority, assignee, subtasks). WebSocket events trigger real-time updates on both the chat stream and the Kanban board simultaneously.

4. Container Orchestration & Secure Ingress

• Problem: Running Next.js SSR, Go REST API, WebSocket streams, Redis, RabbitMQ, and PostgreSQL requires clean networking, health checks, and single-port SSL/HTTP routing.
• Solution: Configured an Nginx reverse proxy routing / to Next.js (port 3003) and /api + /uploads to Go (port 8081) with full WebSocket upgrade headers. Docker Compose healthchecks ensure database readiness before API startup.