infra · hosting

Docker

78 production projects and 5 rule sets built with Docker.

Production projects

Self-Hosted Real-Time Push Server Classic Gotify Gotify keeps the server one deployable Go binary by embedding its Vite/React web UI, using Gin and gorilla/websocket for the REST and streaming API, and swapping SQLite, MySQL or PostgreSQL through GORM, while a compiled Go plugin system handles extensibility instead of a scripting layer.
Monitoring & Observability Dashboard Classic Grafana Grafana splits its backend into a growing set of independently versioned Go modules under apps/, tied together by a go.work workspace and modeled with Kubernetes-style APIs (pkg/apiserver, CUE-defined kinds), so individual product areas like alerting or dashboards can evolve without one monolithic backend module.
S3-Compatible Object Storage Classic RustFS RustFS splits a MinIO-style object store into dozens of single-purpose Rust crates behind one binary, keeps extra protocols behind cargo features, and moves inter-node traffic to gRPC, so storage, healing and IAM evolve separately.
Agentic Development Environment for Parallel Coding Agents Hybrid Orca Agent CLIs stay the user's own. Orca adds the orchestration layer around them: isolated git worktrees, a PTY daemon that outlives the UI, and a relay for mobile steering. It can support new agents without bundling them.
Desktop & Web AI Agent Workspace AI-agent MindsHub (formerly MindsDB) Splitting the client, API and agent into separately versioned git submodules lets each ship on its own cadence (a signed desktop app, a PyPI server package, an agent package), while one Makefile and one docker-compose.yml still bring the whole stack up together.
Distributed Blob & File Storage Classic SeaweedFS Decoupling directory metadata from physical volume storage eliminates central metadata bottlenecks, enabling massive horizontal scaling for small and large files alike.
Team Collaboration Suite Classic Mattermost A single Go binary keeps the API, scheduler, and websocket hub in one deployable process backed by a required PostgreSQL database, while optional Redis, Elasticsearch, and OpenSearch clients let larger deployments add caching and full-text search without changing the core architecture.
Canvas Editor Classic Excalidraw A client-only canvas editor kept free of backend dependencies so it can be embedded anywhere; sharing, live collaboration and persistence are layered on in the app shell with Firebase and a Socket.IO relay.
Developer Tool Classic Supabase Studio Centering the developer experience around PostgreSQL allows Supabase Studio to provide spreadsheet-like table editing and SQL execution directly on production databases.
Scheduling SaaS Classic Cal.com Splitting the tRPC-based web app from an independently versioned NestJS Platform API lets Cal.com serve both its own product and third-party developers from one monorepo, while Turborepo and per-integration app-store packages keep dozens of calendar/payment providers buildable and testable in isolation.
Federated Link Aggregator & Forum Classic Lemmy Lemmy splits its Rust backend into many small crates (per database view, API, ActivityPub, email) over one PostgreSQL schema with heavy migrations, so federation, the local API and queries evolve separately while a single binary serves an instance.
Shell History Sync Classic Atuin Atuin keeps history local in SQLite and encrypts it before sync, so the Axum sync server stays a thin store; a gRPC daemon and capability crates (CLI, server, AI, dotfiles) let each part evolve behind feature flags.
Identity Management Platform Classic Kanidm Kanidm ships every identity protocol from one Rust server with bundled SQLite and built-in replication, renders its UI with Axum, Askama and htmx, and maintains its own WebAuthn, JWT and LDAP crates to keep security-critical code under its control.
Open-Source Payments Orchestration Classic Hyperswitch Hyperswitch runs a panic-averse Rust router on Actix Web with Redis absorbing hot writes and a drainer persisting them to PostgreSQL, while a routing DSL that also compiles to WebAssembly keeps processor selection consistent between server and browser.
Multi-Agent Interactive AI Classroom Classic OpenMAIC Built as a Next.js app around a set of npm-published packages (slide DSL, generation, renderer, editor, importer, storage). The multi-agent LangGraph pipeline, the slide format and persistence can each be reused or swapped, and heavy video rendering runs in a separate container.
Local AI Voice Cloning & Speech Studio Hybrid VoiceStudio Heavy model work stays in a Python FastAPI backend with a pluggable, hardware-aware engine registry. Desktop, web, MCP and remote-worker clients all use the same local API, so voice models run on the user's own GPU without a cloud dependency.
LLM Knowledge Base & RAG Platform Classic WeKnora Retrieval, agents and the API sit in one Go service, and parsing is delegated to a Python gRPC service. Storage backends are pluggable, so the same codebase runs as a lite SQLite binary or a full Kubernetes deployment on existing Postgres, Elasticsearch or vector databases.
Open-Source SEO Research Platform Hybrid OpenSEO Running on Cloudflare Workers with D1, Workflows and Durable Objects makes it free-tier friendly to self-host and to scale when hosted. Supporting both D1 and Postgres through Drizzle, plus a Docker path, keeps the project portable beyond Cloudflare.
Lightweight Self-Hosted Password Vault Classic Vaultwarden Vaultwarden replaces the heavy, multi-container official Bitwarden stack with a single fast Rust executable consuming minimal RAM.
Columnar Real-Time Analytical Database (OLAP) Classic ClickHouse A single CMake super-project that vendors ~150 native dependencies (Arrow, gRPC, AWS/Azure/GCS SDKs, NuRaft, Delta Lake kernel) under contrib/ lets ClickHouse ship a largely self-contained, dependency-free binary and Docker image.
Open-Source Team Communications & WebRTC Classic Rocket.Chat Combining full on-premises MongoDB ownership with real-time WebSockets gives enterprise organizations secure, private communication without third-party surveillance.
High-Throughput LLM Inference & Serving Engine AI-agent vLLM vLLM solves GPU memory fragmentation in large language model serving, delivering state-of-the-art throughput on commodity and enterprise hardware.
Instant GraphQL Engine & Unified Data Access Classic Hasura Hasura runs two independently evolving query engines from one repository — a Haskell V2 server and a Rust V3 engine — and extends database support through an out-of-process Data Connector protocol, so a new database backend plugs in as a separate agent instead of new code inside either engine.
Next-Generation Node.js & TypeScript ORM Classic Prisma Declarative schema modeling combined with modular driver adapters allows Prisma to generate fully type-safe database clients that run consistently from Node servers to edge runtimes.

Often used with Docker

Every rule ships as files

AGENTS.md rules and agent skills with Docker

fastapi-jev-decision-service/AGENTS.mdFastAPI + Jev Decision Service (Python)Python rules for a Jev decision service: FastAPI, the async typesafe-sdk client, a typed question registry, confidence thresholds, decision logs and replay tests. intermediate go-echo-sqlite/AGENTS.mdGo + Echo + SQLite (Embedded, Self-Hosted Tools)Architecture guidelines for single-binary Go services using the Echo framework, embedded SQLite, and minimal-JS server-rendered UI. intermediate go-postgres-react/AGENTS.mdGo + PostgreSQL (pgx & sqlc) + ReactHigh-throughput systems architecture rules for Go (Golang), pgxpool connection management, sqlc type-safe query generation, and React web dashboards. advanced rust-axum-postgres/AGENTS.mdRust + Axum + PostgreSQL API (sqlx & Tokio)Rust API and backend rules: Axum 0.8 on Tokio, compile-time SQL checks with sqlx 0.9, Tower middleware, typed errors and a cargo check loop for AI agents. advanced rust-loco-saas/AGENTS.mdLoco + SeaORM + PostgreSQL (Rails-Style Rust SaaS)Rails-style Rust SaaS rules for Loco: generators, SeaORM models and migrations, Tera views or htmx scaffolds, JWT auth, background workers and mailers. intermediate

Questions about Docker

How many production projects use Docker?

78 verified production projects in the STACK IT FAST directory use Docker, each with a full architecture breakdown.

What is Docker most often used with?

Across projects in the directory, Docker is most commonly paired with TypeScript, PostgreSQL, Redis.

Is there an AGENTS.md rule or Claude Code skill for Docker?

Yes — FastAPI + Jev Decision Service (Python), Go + Echo + SQLite (Embedded, Self-Hosted Tools), Go + PostgreSQL (pgx & sqlc) + React, Rust + Axum + PostgreSQL API (sqlx & Tokio), Loco + SeaORM + PostgreSQL (Rails-Style Rust SaaS) each include a full AGENTS.md, CLAUDE.md, Cursor .mdc rule set and an installable SKILL.md covering Docker.