PMS-GO Enterprise Project Management System

Self-hosted, multi-tenant project management suite built as a Go + Rust + Next.js monorepo.

An enterprise project management system built as a Go + Rust + Next.js monorepo that runs with a single Docker Compose command. The API requires bearer tokens on every route and supports MFA with TOTP enrolment; sensitive secrets such as TOTP keys and push tokens are encrypted at rest with AES-256-GCM. It ships 48 feature modules, including kanban boards, gantt charts, tasks, issues, OKRs, time tracking, invoicing, helpdesk, client portal, meetings, risks, procurement, whiteboard, and workflow, backed by four Rust crates for biometrics, cryptography, licensing, and synchronization. Data lives in PostgreSQL when online and switches to SQLite for offline operation, with a dedicated offline-sync UI.

Role
Sole architect & developer — requirements, schema, API, and implementation

The problem

Teams running delivery, operations, and stakeholder-facing work were stitching together separate SaaS tools for kanban, invoicing, helpdesk, and field work with no offline story — with no single self-hosted platform to run all of it together.

The approach

Analyzed the business requirements end-to-end, designed the PostgreSQL/SQLite schema and REST API surface, then implemented all 48 feature modules — kanban boards, gantt charts, OKRs, time tracking, invoicing, helpdesk, client portal, meetings, risk registers, procurement, whiteboard, and workflow — plus bearer-token auth with MFA/TOTP enrolment, AES-256-GCM encryption at rest for TOTP secrets and push tokens, and four dedicated Rust crates handling biometrics, cryptography, licensing, and sync. The whole stack comes up with one `docker compose` command.

The outcome

Unified planning, execution, and business operations in one self-hosted system: kanban, gantt, and OKR tools for delivery; invoicing, procurement, and contracts for operations; helpdesk and client portal for stakeholders — with offline-first data (PostgreSQL online, SQLite offline) and encrypted secrets throughout.

Stack

  • Go
  • Rust
  • Next.js
  • PostgreSQL
  • SQLite
  • Docker Compose

How it's built

Watch the system move between operational states, and trace a single request step by step through the stack.

PMS-GO Architecture

ONLINE REPLICATION
Next.js Client Portal48 Modules · UI
Features:Kanban • Gantt • Invoicing
Client State:Hydrated (Cloud)
Go API Gateway + 4 Rust CratesSingle Binary
Security:AES-256-GCM + TOTP
Sync Engine:PostgreSQL Delta Stream
SQLiteFIELD OPS
State:Standby
Latency:< 1 ms local
PostgreSQLTHE TRUTH
State:Master ✓
Ping:18ms wire
Online mode. All operations stream direct to PostgreSQL with bearer auth and MFA check.

Stack ships with `docker compose up`.

PMS-GO • Hybrid Runtime Pipeline

STEP 1/6
Frontend • Next.js 48-Module UI
user interacts with Gantt & Kanban boards; network drops and triggers the offline-sync UI • 0 ms local
Offline Storage • Embedded SQLite
switches to local SQLite store; tasks, time tracking, & risk registers mutate without network interruption • ~2 ms write
Native Extensions • Rust Crates
crypto crate seals sensitive data with AES-256-GCM; validates local license and biometric payloads • ~5 ms
API Gateway • Go Monorepo Core
connection restored; routes demand Bearer tokens + TOTP MFA verification on every endpoint • ~12 ms
Delta Engine • Rust Sync Crate
reconciles local SQLite mutations with remote ledger; resolves multi-tenant conflict deltas cleanly
Master DB • PostgreSQL 16 (Online)
commits synced modules into primary schema; encrypted TOTP keys and push tokens stored securely at rest • synced
Enterprise Fault Tolerance: Seamless resilience via dual-engine storage (PostgreSQL ↔ SQLite), secured at rest with AES-256-GCM and accelerated through high-performance Rust crates.

System architecture

Open in new tab ↗

← All projects