Self-hostable team workspace: Kanban tasks, real-time chat, a shared whiteboard, and a constraint-solver task scheduler in one Docker Compose stack.
Quick start · Features · Architecture · Docs · Team
STRIDE is a workspace for software teams that you host yourself. Projects, a Kanban board, chat and a shared whiteboard sit in one place, and every change shows up live in all open browsers. A constraint solver suggests who should work on which task, based on skills, working hours and deadlines. A team lead reviews each suggestion before it is applied. The whole stack installs on a server with one command.
STRIDE was built as an Advanced Software Engineering project at TU Wien.
| 776 commits | 98 merged PRs | ~50k lines | 11 ADRs | 200+ automated tests |
|---|---|---|---|---|
| 5 engineers | reviewed MRs | Go · TS · Python | arc42 docs | Go · Vitest · Playwright |
|
Create, archive and delete projects. Invite members as Owner or Member. Archived projects become read-only across tasks, chat and whiteboard. Drag-and-drop board built on Chat per project, available on every page as a side panel. Read receipts use per-member delivered/read cursors. |
An Excalidraw canvas with live element sync, live cursors, a collaborator list, templates, and task ↔ region linking. Edits are debounced into Redis and a background worker flushes them to PostgreSQL. A Google OR-Tools CP-SAT solver assigns tasks by skill, working hours, estimates and deadlines. Optimization goals can be stacked. Nothing is applied until a human reviews and confirms the proposal. Per-user notifications backed by Redis Streams, with snapshot replay on reconnect. Full English and German UI, dark mode, and a responsive layout. |
Requirements: Docker with Compose v2. Nothing else runs on the host.
git clone https://github.com/advxolltm/stride.git && cd stride
cp .env.example .env
./stride devrunOpen http://localhost:8080 and sign in with the development superuser:
| Username | Password | |
|---|---|---|
admin |
admin@example.com |
Password123! |
Without the CLI
docker compose -f compose.dev.yml up -d --build
curl -s http://localhost:8080/api/v1/health./stride start Interactive production setup and start
./stride devrun Start the development Docker Compose stack
./stride down [prod|dev] Stop a stack, defaults to prod
./stride restart [prod|dev] Restart containers, defaults to prod
./stride certificate Configure production TLS certificates
./stride test Run frontend and backend test cycle
./stride startThe interactive setup:
- writes
.envand asks for the deployment mode (public internet or VPN/corporate network) - issues TLS certificates with
certbot, or takes your own certificate files, and installs a renewal cron job - starts
compose.prod.ymland creates the first superuser
Only nginx is exposed (ports 80/443). PostgreSQL, Redis, the API and the solver stay on the internal Docker network. Persistent data lives in ./data/{db,redis,media}.
APPLICATION_MODE |
Registration |
|---|---|
closed_network (default) |
Open self-registration. Meant for VPN or intranet installs. |
closed_auth |
Only superusers can create accounts. Meant for public internet installs. |
STRIDE is a modular monolith (ADR-0006). One Go API holds all business modules. PostgreSQL is the only source of truth, and Redis carries everything live. The CP-SAT solver runs as a small Python sidecar.
flowchart LR
browser(["Browser"]) -->|HTTPS / WSS| nginx["nginx<br/>reverse proxy · TLS"]
subgraph compose["Docker Compose"]
nginx -->|/| spa["React SPA<br/>Vite · RTK Query"]
nginx -->|/api/v1| api["Go API<br/>Echo v5"]
api -->|SQL · migrations| pg[("PostgreSQL 16<br/>source of truth")]
api -->|pub/sub · streams · pending ops| redis[("Redis 8<br/>real-time backbone")]
api -->|HTTP JSON| solver["Scheduler<br/>Python · OR-Tools CP-SAT"]
end
Every change goes through the same pipeline: validate → persist → publish → fan out. Because the database write happens first, a client that reconnects just refetches the saved state. Nothing is lost when a socket drops.
sequenceDiagram
participant A as Client A
participant API as Go API
participant DB as PostgreSQL
participant R as Redis pub/sub
participant H as WebSocket hub
participant B as Client B
A->>API: move task / send message / edit canvas
API->>DB: write authoritative state
API->>R: PUBLISH project event
R-->>H: event
H-->>B: push update (RTK Query cache patch)
| Channel | Transport | Purpose |
|---|---|---|
/ws/project/:id/tasks · /chat |
gorilla/websocket + Redis pub/sub | Task, Kanban and chat events per project |
/ws/project/:id/whiteboard |
WebSocket + Redis pending ops | Live element ops. A flusher goroutine writes them to PostgreSQL |
/ws/project/:id/whiteboard/cursor |
process-local cursor hub | Whiteboard cursor presence |
/ws/notifications |
Redis Streams (XRANGE snapshot → XREAD BLOCK) |
Per-user notifications with replay |
Clients reconnect with exponential back-off and jitter. Each socket's hub owner, reader, pinger and flusher run in separate goroutines (ADR-0008).
sequenceDiagram
participant L as Team lead
participant API as Go adapter
participant S as CP-SAT solver
L->>API: POST /projects/:id/scheduler
API->>S: tasks, skills, working hours, deadlines, goals
S-->>API: best assignment within timeout
API-->>L: reviewable proposal
L->>API: POST /projects/:id/scheduler/confirm
The solver models each task as an optional interval per qualified member. A member lacking a required skill is ruled out by a hard constraint. Assignments you set by hand are kept wherever possible. After that, the ordered goals are optimized one after another:
min-makespan · distribute-evenly (relative to weekly hours) · max-tasks-scheduled · max-hours-scheduled
.
├── backend/ Go 1.26 · Echo v5 · GORM/pgx
│ ├── cmd/ server, create-user, seed-demo
│ ├── routes/ HTTP handlers + websocket/ hubs
│ ├── services/ domain logic (auth, project, task, chat, whiteboard, notification, scheduler)
│ │ └── scheduler/ Go adapter + scheduler.service.py (OR-Tools)
│ ├── db/ stores per aggregate + SQL migrations
│ ├── models/ persistence models
│ └── docs/ generated OpenAPI (swaggo v2)
├── frontend/ React 19 · TypeScript · Vite 8 · HeroUI · Tailwind 4
│ ├── src/store/features/ RTK Query slices + socket lifecycle per feature
│ ├── src/components/ account, auth, project (overview/settings/space), notification
│ ├── src/i18n/locales/ en, de
│ └── e2e/ Playwright specs
├── nginx/ dev + production configs
├── docs/architecture/ arc42 document + ADRs
├── compose.dev.yml full dev stack with hot reload
├── compose.prod.yml production stack (only nginx exposed)
├── .gitlab-ci.yml build → test → deploy pipeline
└── stride operator CLI
| Layer | Choice |
|---|---|
| Frontend | React 19, TypeScript, Vite, Redux Toolkit + RTK Query, React Router 7, Zod, i18next |
| UI | HeroUI v3, Tailwind CSS 4, lucide-react, dnd-kit, Excalidraw |
| Backend | Go 1.26, Echo v5, echo-jwt, GORM + pgx, golang-migrate, gorilla/websocket |
| Data | PostgreSQL 16, Redis 8.4 (pub/sub, Streams) |
| Scheduling | Python 3.14, Google OR-Tools CP-SAT, msgspec |
| Ops | Docker Compose, nginx, certbot, GitLab CI |
| Quality | testify, Testcontainers, Vitest, Playwright, ESLint, Prettier, golangci-lint, govulncheck |
REST under /api/v1, documented with OpenAPI (swaggo v2). Swagger UI runs on the API server at http://localhost:8000/swagger/index.html in dev. Authentication is a JWT in an HTTP-only cookie.
| Area | Endpoints |
|---|---|
| Auth | POST /auth/login · POST /auth/logout · GET /auth/session |
| Users | profile, password change/reset, skills, working hours per project |
| Projects | CRUD, archive, members, project skills, POST /:id/scheduler · /:id/scheduler/confirm |
| Tasks | CRUD, move, assign/unassign, add-skill/remove-skill, Kanban view, my tasks |
| Chat | messages CRUD, delivered/read cursors |
| Whiteboard | elements CRUD, bulk upsert/delete |
| Notifications | list, count, mark read |
Regenerate the spec after changing handlers: see backend/README.md.
./stride test # full cycle: backend (with Redis + solver) and frontend| Suite | Tooling | Scope |
|---|---|---|
| Backend unit & integration | go test, testify, Testcontainers (PostgreSQL, Redis) |
stores, services, handlers, WebSocket hubs, migrations, scheduler adapter |
| Frontend unit | Vitest + jsdom | store logic, utils, components |
| End-to-end | Playwright | auth, projects, settings and permissions, tasks (list, drag, live sync), chat, notifications, scheduler, archived read-only |
| Static analysis | ESLint, tsc --noEmit, golangci-lint, govulncheck |
runs in CI on every MR |
The GitLab pipeline (.gitlab-ci.yml) runs build → test on every merge request and on develop, and build → test → deploy on main.
| Document | Contents |
|---|---|
| Architecture (arc42) | goals, context, building blocks, runtime and deployment views, risks |
| ADR-0001 | Go + Echo over Gin / NestJS |
| ADR-0002 | PostgreSQL as the only source of truth |
| ADR-0003 | Redis pub/sub over an in-memory hub |
| ADR-0004 | WebSocket library evaluation |
| ADR-0005 | Persistence: sqlc vs GORM vs database/sql |
| ADR-0006 | Modular monolith over microservices |
| ADR-0007 | Redis Streams for notifications |
| ADR-0008 | Goroutine split for real-time workers |
| ADR-0009 | gorilla/websocket + Redis project hub |
| ADR-0010 | Excalidraw as whiteboard framework |
| ADR-0011 | OR-Tools CP-SAT for scheduling |
| Start-up guide | Compose operations, container access, production notes |
| Backend guide | local build, application modes, user CLI, Swagger generation |
Released under the MIT License.





