# STACK IT FAST — Production Software Architectures, AGENTS.md, Cursor Rules & Agent Skills Index

> STACK IT FAST is the open-source directory of verified, production-grade tech stacks, AGENTS.md rules, Cursor rules (.mdc), and Agent Skills (SKILL.md). It provides battle-tested architectures used by iconic software products (Next.js, Supabase, FastAPI, Cal.com, n8n, Tailwind CSS, Bun, LangChain, Dub, Ghost, PostHog) with copy-paste prompt blueprints and rule sets for AI coding assistants (Cursor, Claude Code, Antigravity, Windsurf, Copilot).

## Core Index & Resources
- [Explore Directory](https://stackitfast.com/explore): Full searchable catalog of verified production stacks.
- [AI Agent Stack Rules, Cursor Rules & Skills](https://stackitfast.com/rules): Battle-tested coding standards as AGENTS.md, Cursor rules (.mdc), and Claude Code / Agent Skills (SKILL.md).
- [Architecture Insights & Trends](https://stackitfast.com/insights): Monthly verified software architecture trend reports and benchmarks.
- [Technology Directory](https://stackitfast.com/stack): Every tracked technology, each linked to its real production projects and AGENTS.md rules.
- [Full LLM Knowledge Bundle](https://stackitfast.com/llms-full.txt): Complete concatenated compilation of all reference architectures and scaffolding guides.
- [OpenAPI 3.1 Specification](https://stackitfast.com/api/openapi.json): Machine-readable schema for agent function calling.

## AI Coding Agent Stack Rules & Skills (AGENTS.md, Cursor Rules & SKILL.md)
Each entry links the combined rules bundle (.md) and the installable Agent Skill (SKILL.md → .claude/skills/<slug>/SKILL.md).
- [Astro SSR + Tailwind CSS + Cloudflare](https://stackitfast.com/rules/astro-tailwind-cloudflare.md): Architecture rules for Astro server-side rendering, React client islands, Tailwind CSS, and Cloudflare Pages/Workers edge deployment. (Technologies: Astro, Tailwind CSS, Cloudflare, TypeScript, React) · SKILL.md: https://stackitfast.com/rules/astro-tailwind-cloudflare/SKILL.md
- [Bun + Hono + SQLite (libSQL & Drizzle ORM)](https://stackitfast.com/rules/bun-hono-sqlite.md): Ultra-fast edge API architecture using Bun.serve(), Hono v4, Drizzle ORM with embedded SQLite / Turso libSQL, and Zod OpenAPI validation. (Technologies: Bun, Hono, SQLite, Drizzle, TypeScript, Zod) · SKILL.md: https://stackitfast.com/rules/bun-hono-sqlite/SKILL.md
- [Expo Router + React Native + NativeWind](https://stackitfast.com/rules/expo-react-native-tailwind.md): Modern cross-platform mobile architecture for Expo SDK 52, Expo Router v4 file-based routing, React Native, NativeWind v4, and TanStack Query. (Technologies: Expo, React Native, NativeWind, Tailwind CSS, TypeScript, iOS, Android) · SKILL.md: https://stackitfast.com/rules/expo-react-native-tailwind/SKILL.md
- [Django + PostgreSQL + Redis + Celery](https://stackitfast.com/rules/django-postgres-redis.md): Production guidelines for Django 5 enterprise applications, PostgreSQL connection pooling, Redis caching, and Celery async workers. (Technologies: Django, Python, PostgreSQL, Redis, Celery, React) · SKILL.md: https://stackitfast.com/rules/django-postgres-redis/SKILL.md
- [FastAPI + Python + PostgreSQL (Async SQLAlchemy & Pydantic v2)](https://stackitfast.com/rules/fastapi-python-postgres.md): Production guidelines for FastAPI, Pydantic v2 validation, Async SQLAlchemy 2.0 (asyncpg), Alembic migrations, and PostgreSQL/Redis. (Technologies: FastAPI, Python, PostgreSQL, SQLAlchemy, Alembic, Pydantic, Redis) · SKILL.md: https://stackitfast.com/rules/fastapi-python-postgres/SKILL.md
- [Go + Echo + SQLite (Embedded, Self-Hosted Tools)](https://stackitfast.com/rules/go-echo-sqlite.md): Architecture guidelines for single-binary Go services using the Echo framework, embedded SQLite, and minimal-JS server-rendered UI. (Technologies: Go, Echo, SQLite, Docker) · SKILL.md: https://stackitfast.com/rules/go-echo-sqlite/SKILL.md
- [Go + PostgreSQL (pgx & sqlc) + React](https://stackitfast.com/rules/go-postgres-react.md): High-throughput systems architecture rules for Go (Golang), pgxpool connection management, sqlc type-safe query generation, and React web dashboards. (Technologies: Go, PostgreSQL, React, Docker, TypeScript) · SKILL.md: https://stackitfast.com/rules/go-postgres-react/SKILL.md
- [LangGraph + Python + FastAPI (Agentic AI Workflows)](https://stackitfast.com/rules/langgraph-python-fastapi.md): Production architecture for autonomous multi-agent systems, LangGraph cyclic state graphs, Pydantic v2 structured tool calling, and Chroma/Qdrant vector stores. (Technologies: LangGraph, LangChain, FastAPI, Python, Pydantic, Vector DB) · SKILL.md: https://stackitfast.com/rules/langgraph-python-fastapi/SKILL.md
- [Laravel + Livewire + PostgreSQL](https://stackitfast.com/rules/laravel-livewire-postgres.md): Production guidelines for Laravel 11 monoliths, Livewire reactive components, Eloquent ORM query discipline, and queued job workers. (Technologies: Laravel, Livewire, PHP, PostgreSQL, Alpine.js, Tailwind CSS) · SKILL.md: https://stackitfast.com/rules/laravel-livewire-postgres/SKILL.md
- [NestJS + PostgreSQL + Redis + BullMQ](https://stackitfast.com/rules/nestjs-postgres-redis.md): Enterprise backend architecture guidelines for NestJS modular design, PostgreSQL connection pooling, Redis BullMQ background jobs, and DTO validation. (Technologies: NestJS, Node.js, TypeScript, PostgreSQL, Redis, BullMQ) · SKILL.md: https://stackitfast.com/rules/nestjs-postgres-redis/SKILL.md
- [Next.js 15 + Drizzle ORM + Supabase](https://stackitfast.com/rules/nextjs-drizzle-supabase.md): Production guidelines for Next.js App Router, Drizzle ORM with postgres-js, Supabase Transaction Pooler (prepare: false), and RLS security. (Technologies: Next.js, Drizzle, Supabase, TypeScript, Tailwind CSS, PostgreSQL) · SKILL.md: https://stackitfast.com/rules/nextjs-drizzle-supabase/SKILL.md
- [Next.js + ClickHouse + Prisma (Analytics & Observability)](https://stackitfast.com/rules/nextjs-clickhouse-analytics.md): Architecture guidelines for high-volume event ingestion and analytical queries using ClickHouse alongside a PostgreSQL/Prisma control plane. (Technologies: Next.js, ClickHouse, Prisma, PostgreSQL, TypeScript) · SKILL.md: https://stackitfast.com/rules/nextjs-clickhouse-analytics/SKILL.md
- [Next.js 15 + Prisma ORM + PostgreSQL](https://stackitfast.com/rules/nextjs-prisma-postgres.md): Production guidelines for Next.js App Router, Server Actions, Prisma connection pooling, PgBouncer/Neon tuning, and Zod schema validation. (Technologies: Next.js, Prisma, PostgreSQL, TypeScript, Tailwind CSS) · SKILL.md: https://stackitfast.com/rules/nextjs-prisma-postgres/SKILL.md
- [Nuxt 3 + Vue + PostgreSQL](https://stackitfast.com/rules/nuxt-vue-postgres.md): Production guidelines for Nuxt 3 server routes and universal rendering, Vue 3 Composition API, and PostgreSQL via a typed query layer. (Technologies: Nuxt, Vue, PostgreSQL, Supabase, TypeScript, Tailwind CSS) · SKILL.md: https://stackitfast.com/rules/nuxt-vue-postgres/SKILL.md
- [Elixir + Phoenix LiveView + PostgreSQL](https://stackitfast.com/rules/phoenix-liveview-postgres.md): Real-time reactive web architecture for Elixir 1.17, Phoenix 1.7+, LiveView HTML-over-WebSockets, OTP supervision trees, and Ecto. (Technologies: Elixir, Phoenix, LiveView, PostgreSQL, Ecto, Tailwind CSS) · SKILL.md: https://stackitfast.com/rules/phoenix-liveview-postgres/SKILL.md
- [Ruby on Rails + PostgreSQL + Redis + Sidekiq](https://stackitfast.com/rules/rails-postgres-redis.md): Production guidelines for Ruby on Rails monoliths, ActiveRecord pool tuning, Redis Sidekiq background jobs, and modern Hotwire or React UI architecture. (Technologies: Rails, Ruby, PostgreSQL, Redis, Sidekiq) · SKILL.md: https://stackitfast.com/rules/rails-postgres-redis/SKILL.md
- [Rust + Axum + PostgreSQL (sqlx & Tokio)](https://stackitfast.com/rules/rust-axum-postgres.md): High-concurrency systems architecture for Rust 2024, Axum 0.8, Tokio async runtime, compile-time SQL verification with sqlx, and Tower middleware. (Technologies: Rust, Axum, PostgreSQL, sqlx, Tokio, Docker) · SKILL.md: https://stackitfast.com/rules/rust-axum-postgres/SKILL.md
- [SvelteKit + PostgreSQL + Drizzle ORM](https://stackitfast.com/rules/sveltekit-postgres-drizzle.md): Production guidelines for SvelteKit form actions and load functions, Drizzle ORM over PostgreSQL, and Svelte 5 runes-based reactivity. (Technologies: SvelteKit, Svelte, PostgreSQL, Supabase, Drizzle, TypeScript, Tailwind CSS) · SKILL.md: https://stackitfast.com/rules/sveltekit-postgres-drizzle/SKILL.md
- [Vite + React SPA + Hono (Edge API)](https://stackitfast.com/rules/vite-react-hono-edge.md): Architecture guidelines for zero-server-lag single-page apps built with Vite and React, backed by a Hono API on Cloudflare Workers. (Technologies: Vite, React, Hono, TypeScript, Cloudflare) · SKILL.md: https://stackitfast.com/rules/vite-react-hono-edge/SKILL.md
- [Node.js + Express + MongoDB](https://stackitfast.com/rules/node-express-mongodb.md): Production guidelines for Express REST APIs, Mongoose schema design, and MongoDB indexing/transaction discipline. (Technologies: Node.js, Express, MongoDB, TypeScript, Redis) · SKILL.md: https://stackitfast.com/rules/node-express-mongodb/SKILL.md

## Browse by Category
- [Developer Tool & API](https://stackitfast.com/explore/devtools): CLIs, developer utilities, code tools, and API frameworks. 21 project(s), 9 rule(s).
- [SaaS / Web App](https://stackitfast.com/explore/saas): Multi-tenant products where users log in, manage data, and often pay subscriptions. 10 project(s), 11 rule(s).
- [AI / LLM App](https://stackitfast.com/explore/ai): LLM apps, agents, RAG, inference engines, and AI orchestration. 13 project(s), 3 rule(s).
- [Data & Storage Infra](https://stackitfast.com/explore/data-infra): Databases, object storage, data pipelines, and query engines. 14 project(s), 2 rule(s).
- [Analytics & Dashboards](https://stackitfast.com/explore/analytics): Visual charts, metrics, and live data tracking. 14 project(s), 1 rule(s).
- [Internal Admin Tool](https://stackitfast.com/explore/internal-tools): Backoffice panels for a team to manage data. 6 project(s), 6 rule(s).
- [Content & Directory](https://stackitfast.com/explore/content): Curated resources, catalogs, blogs, and content-first sites. 7 project(s), 1 rule(s).
- [Collaboration & Productivity](https://stackitfast.com/explore/collaboration): Team workspaces, docs, chat, and productivity suites. 6 project(s), 2 rule(s).
- [DevOps & Infrastructure](https://stackitfast.com/explore/devops): Deployment, container orchestration, and infra automation. 3 project(s), 2 rule(s).
- [Auth & Identity](https://stackitfast.com/explore/auth-identity): Identity providers, SSO, and access management. 4 project(s), 0 rule(s).
- [Workflow & Automation](https://stackitfast.com/explore/automation): Workflow automation, orchestration, and integration engines. 4 project(s), 0 rule(s).

## Technology Directory
- [TypeScript](https://stackitfast.com/stack/typescript): 47 project(s), 12 rule(s).
- [React](https://stackitfast.com/stack/react): 33 project(s), 4 rule(s).
- [Redis](https://stackitfast.com/stack/redis): 26 project(s), 5 rule(s).
- [Docker](https://stackitfast.com/stack/docker): 26 project(s), 3 rule(s).
- [Node.js](https://stackitfast.com/stack/nodejs): 24 project(s), 2 rule(s).
- [PostgreSQL](https://stackitfast.com/stack/postgresql): 10 project(s), 13 rule(s).
- [Go](https://stackitfast.com/stack/go): 17 project(s), 2 rule(s).
- [Next.js](https://stackitfast.com/stack/nextjs): 16 project(s), 3 rule(s).
- [Python](https://stackitfast.com/stack/python): 15 project(s), 3 rule(s).
- [SQLite](https://stackitfast.com/stack/sqlite): 14 project(s), 2 rule(s).
- [Rust](https://stackitfast.com/stack/rust): 13 project(s), 1 rule(s).
- [Tailwind CSS](https://stackitfast.com/stack/tailwind-css): 6 project(s), 8 rule(s).
- [Prisma](https://stackitfast.com/stack/prisma): 9 project(s), 2 rule(s).
- [ClickHouse](https://stackitfast.com/stack/clickhouse): 8 project(s), 1 rule(s).
- [Django](https://stackitfast.com/stack/django): 6 project(s), 1 rule(s).
- [C++](https://stackitfast.com/stack/cpp): 6 project(s), 0 rule(s).
- [FastAPI](https://stackitfast.com/stack/fastapi): 4 project(s), 2 rule(s).
- [Express](https://stackitfast.com/stack/express): 4 project(s), 1 rule(s).
- [NestJS](https://stackitfast.com/stack/nestjs): 4 project(s), 1 rule(s).
- [WebSockets](https://stackitfast.com/stack/websockets): 5 project(s), 0 rule(s).
- [Pydantic](https://stackitfast.com/stack/pydantic): 3 project(s), 2 rule(s).
- [MongoDB](https://stackitfast.com/stack/mongodb): 4 project(s), 1 rule(s).
- [Tokio](https://stackitfast.com/stack/tokio): 4 project(s), 1 rule(s).
- [Vue](https://stackitfast.com/stack/vue): 3 project(s), 1 rule(s).
- [Svelte](https://stackitfast.com/stack/svelte): 3 project(s), 1 rule(s).
- [Rails](https://stackitfast.com/stack/rails): 3 project(s), 1 rule(s).
- [Kafka](https://stackitfast.com/stack/kafka): 4 project(s), 0 rule(s).
- [WebAssembly](https://stackitfast.com/stack/webassembly): 4 project(s), 0 rule(s).
- [PHP](https://stackitfast.com/stack/php): 2 project(s), 1 rule(s).
- [Elixir](https://stackitfast.com/stack/elixir): 2 project(s), 1 rule(s).
- [Nuxt](https://stackitfast.com/stack/nuxt): 2 project(s), 1 rule(s).
- [SvelteKit](https://stackitfast.com/stack/sveltekit): 2 project(s), 1 rule(s).
- [Vite](https://stackitfast.com/stack/vite): 2 project(s), 1 rule(s).
- [GraphQL](https://stackitfast.com/stack/graphql): 3 project(s), 0 rule(s).
- [Celery](https://stackitfast.com/stack/celery): 2 project(s), 1 rule(s).
- [Sidekiq](https://stackitfast.com/stack/sidekiq): 2 project(s), 1 rule(s).
- [Zod](https://stackitfast.com/stack/zod): 2 project(s), 1 rule(s).
- [MySQL](https://stackitfast.com/stack/mysql): 3 project(s), 0 rule(s).
- [pgvector](https://stackitfast.com/stack/pgvector): 3 project(s), 0 rule(s).
- [Drizzle](https://stackitfast.com/stack/drizzle): 0 project(s), 3 rule(s).
- [TypeORM](https://stackitfast.com/stack/typeorm): 3 project(s), 0 rule(s).
- [Supabase](https://stackitfast.com/stack/supabase): 0 project(s), 3 rule(s).
- [Turborepo](https://stackitfast.com/stack/turborepo): 3 project(s), 0 rule(s).
- [LangGraph](https://stackitfast.com/stack/langgraph): 2 project(s), 1 rule(s).
- [Java](https://stackitfast.com/stack/java): 2 project(s), 0 rule(s).
- [Clojure](https://stackitfast.com/stack/clojure): 2 project(s), 0 rule(s).
- [React Native](https://stackitfast.com/stack/react-native): 1 project(s), 1 rule(s).
- [Angular](https://stackitfast.com/stack/angular): 2 project(s), 0 rule(s).
- [Astro](https://stackitfast.com/stack/astro): 1 project(s), 1 rule(s).
- [Alpine.js](https://stackitfast.com/stack/alpinejs): 1 project(s), 1 rule(s).
- [Expo](https://stackitfast.com/stack/expo): 1 project(s), 1 rule(s).
- [Hono](https://stackitfast.com/stack/hono): 0 project(s), 2 rule(s).
- [Flask](https://stackitfast.com/stack/flask): 2 project(s), 0 rule(s).
- [Laravel](https://stackitfast.com/stack/laravel): 1 project(s), 1 rule(s).
- [Phoenix](https://stackitfast.com/stack/phoenix): 1 project(s), 1 rule(s).
- [tRPC](https://stackitfast.com/stack/trpc): 2 project(s), 0 rule(s).
- [WebRTC](https://stackitfast.com/stack/webrtc): 2 project(s), 0 rule(s).
- [BullMQ](https://stackitfast.com/stack/bullmq): 1 project(s), 1 rule(s).
- [RocksDB](https://stackitfast.com/stack/rocksdb): 2 project(s), 0 rule(s).
- [Tinybird](https://stackitfast.com/stack/tinybird): 2 project(s), 0 rule(s).
- [Cloudflare](https://stackitfast.com/stack/cloudflare): 0 project(s), 2 rule(s).
- [OpenTelemetry](https://stackitfast.com/stack/opentelemetry): 2 project(s), 0 rule(s).
- [LangChain](https://stackitfast.com/stack/langchain): 1 project(s), 1 rule(s).

## Architecture Insights & Benchmark Reports
- [Most Popular Tech Stacks in Modern Open-Source Software (2026 Breakdown)](https://stackitfast.com/insights/most-popular-open-source-tech-stacks.md): Most popular tech stacks powering iconic open-source projects like Cal.com, Supabase, Dub, Sentry, and PostHog. Verified 2026 architecture benchmarks. (Sample Size: 48 verified architectures)
- [August 2026 Production Stack Trends: PostgreSQL Powers 71% of Open-Source Architectures](https://stackitfast.com/insights/2026-08-stack-trends.md): August 2026 stack trends: PostgreSQL powers 71% of open-source architectures. Real data on databases, frameworks, and AI-agent development modes. (Sample Size: 48 verified architectures)
- [Vibe Coding Statistics 2026: AI Coding Agent Adoption Across 105 Production Open-Source Stacks](https://stackitfast.com/insights/vibe-coding-statistics-2026.md): Vibe coding statistics 2026: 43.8% of 105 production open-source stacks use AI-assisted or agent-heavy delivery. Data by language, team size, category. (Sample Size: 105 verified architectures)
- [Top 10 Production Tech Stacks in 2026: Architecture Breakdown of 105 Open-Source Leaders](https://stackitfast.com/insights/top-10-production-tech-stacks.md): Top 10 production tech stacks in 2026: In-depth architecture breakdown across 105 verified open-source leaders like Next.js, Supabase, FastAPI, and MinIO. (Sample Size: 105 verified architectures)

## Verified Reference Architectures
- [elekcsv](https://stackitfast.com/project/elekcsv.md): Headless CSV Ingestion Engine (Solo Developer, CLASSIC) — Stack: TypeScript, Compiled V8 Validators, Zero-Allocation Memory Model, Bitmap Error Indexing, Fuzzy Levenshtein Column Mapping, React Hook. High-performance, headless, locale-aware CSV data ingestion and validation toolkit. Unifies parsing, fuzzy column mapping, and validation into a single pass. Compiles schemas into optimized raw V8 JavaScript functions (new Function()) and utilizes dense bitmasks for O(1) cell error lookups, eliminating Garbage Collector (GC) thrashing on 100k+ row browser imports.
- [Gotify](https://stackitfast.com/project/gotify.md): Self-Hosted Real-Time Push Server (2-5 People, CLASSIC) — Stack: Go, Gin Web Framework, SQLite / PostgreSQL, WebSockets, React. Self-hosted real-time push notification service (Pushover / Pusher alternative). Built in Go with Gin and WebSockets for low-latency message streaming from CI/CD webhooks, server scripts, and IoT alerts directly to desktop/mobile devices.
- [Grafana](https://stackitfast.com/project/grafana.md): Monitoring & Observability Dashboard (20+ people, CLASSIC) — Stack: Go, TypeScript, React, SQLite, Postgres. Universal observability platform; Go backend queries disparate time-series databases and streams real-time telemetry to customizable React panels.
- [MindsDB](https://stackitfast.com/project/mindsdb.md): Federated Enterprise AI & Data SQL Engine (20+ People, AGENT) — Stack: Python, DuckDB, PostgreSQL Wire Protocol, LangChain / LlamaIndex, HuggingFace / OpenAI. Connects enterprise databases directly to AI and machine learning models using standard SQL statements. Enables developers to query, train, and orchestrate generative AI agents and predictive models directly over PostgreSQL, Snowflake, and MongoDB data sources.
- [Mattermost](https://stackitfast.com/project/mattermost.md): Team Collaboration Suite (20+ people, CLASSIC) — Stack: Go, React, TypeScript, Postgres, Docker. High-security enterprise messaging; Go backend with concurrent WebSocket routing and React desktop/web clients.
- [Supabase Studio](https://stackitfast.com/project/supabase-studio.md): Developer Tool (20+ people, CLASSIC) — Stack: Next.js, Postgres, PostgREST, Deno, Tailwind. Database-centric product; most business logic lives in Postgres policies and edge functions.
- [Vaultwarden](https://stackitfast.com/project/vaultwarden.md): Lightweight Self-Hosted Password Vault (Solo / 2-5 people, CLASSIC) — Stack: Rust, Rocket, SQLite, PostgreSQL, WebSockets, Docker. Unofficial Bitwarden compatible server written in Rust; replaces the heavy multi-container C#/.NET stack with a lightweight single-binary service consuming under 50MB of RAM.
- [ClickHouse](https://stackitfast.com/project/clickhouse.md): Columnar Real-Time Analytical Database (OLAP) (20+ people, CLASSIC) — Stack: C++, SIMD, Vectorized Execution, CMake, Linux, SQL. Blazing-fast analytical database; processes queries orders of magnitude faster than traditional row-based engines by scanning only relevant columns with SIMD vector instructions.
- [Nextcloud](https://stackitfast.com/project/nextcloud.md): Self-Hosted Collaborative Productivity Suite (20+ people, CLASSIC) — Stack: PHP, Vue.js, PostgreSQL, Redis, WebDAV, Docker. The world's most deployed self-hosted cloud office suite; gives complete data sovereignty over files, calendars, office collaboration, and communications without third-party surveillance.
- [Rocket.Chat](https://stackitfast.com/project/rocket-chat.md): Open-Source Team Communications & WebRTC (20+ people, CLASSIC) — Stack: TypeScript, React, Node.js, MongoDB, WebRTC, Docker. Enterprise privacy-first Slack alternative; combines real-time messaging, WebRTC video calling, matrix federation, and strict compliance security with full on-premises data ownership.
- [vLLM](https://stackitfast.com/project/vllm.md): High-Throughput LLM Inference & Serving Engine (20+ people, AGENT) — Stack: Python, C++, CUDA, PagedAttention, PyTorch, Ray. The gold standard for production LLM inference; invented PagedAttention to eliminate memory fragmentation in GPU KV caches, delivering 2x-4x throughput over standard Hugging Face runtimes.
- [Hasura](https://stackitfast.com/project/hasura.md): Instant GraphQL Engine & Unified Data Access (20+ people, CLASSIC) — Stack: Haskell, PostgreSQL, GraphQL, TypeScript, React, Docker. Turns databases into high-throughput GraphQL APIs in seconds; compiles GraphQL queries directly into optimized single-query SQL statements in Haskell with enterprise access controls.
- [Payload CMS](https://stackitfast.com/project/payload-cms.md): Next.js-Native Headless CMS & App Framework (6-20 people, HYBRID) — Stack: TypeScript, Next.js, React, PostgreSQL, Drizzle ORM, Tailwind. The modern standard for headless content management; runs completely natively inside Next.js with Drizzle ORM and React Server Components, offering zero-latency Local API calls.
- [tRPC](https://stackitfast.com/project/trpc.md): End-to-End Typesafe API Framework (1M+ MAU, HYBRID) — Stack: TypeScript, Node.js, React Query, Zod, Next.js. Eliminates API schema drift without code generation; TypeScript compiles client and server code together to infer procedure input, output, and error types automatically.
- [Prisma](https://stackitfast.com/project/prisma.md): Next-Generation Node.js & TypeScript ORM (1M+ MAU, CLASSIC) — Stack: TypeScript, Rust, WebAssembly, PostgreSQL, MySQL, SQLite. Benchmark developer experience for relational databases; leverages declarative schema modeling to auto-generate fully type-safe TypeScript clients backed by an optimized query engine.
- [Deno](https://stackitfast.com/project/deno.md): Secure JavaScript & TypeScript Runtime (20+ people, CLASSIC) — Stack: Rust, V8 Engine, Tokio, TypeScript, Web Platform APIs. Modern secure runtime by Ryan Dahl; eliminates node_modules and build pipelines with first-class TypeScript, web standard APIs, and an explicit capability-based security sandbox.
- [Gitea](https://stackitfast.com/project/gitea.md): Lightweight Self-Hosted Git Service (20+ people, CLASSIC) — Stack: Go, Vue.js, SQLite, PostgreSQL, Docker. Frictionless GitHub alternative; written in Go to run on minimal hardware (even a Raspberry Pi) while providing Git repository management, issue tracking, and Docker-based CI/CD pipelines.
- [MinIO](https://stackitfast.com/project/minio.md): High-Performance S3 Object Storage (20+ people, CLASSIC) — Stack: Go, SIMD Assembly, S3 API, Docker, Kubernetes. Standard for private cloud object storage; engineered in Go with SIMD assembly acceleration to deliver multi-gigabyte/sec read/write throughput compatible with the Amazon S3 API.
- [Astro](https://stackitfast.com/project/astro.md): Island Architecture Web Framework (1M+ MAU, HYBRID) — Stack: TypeScript, Vite, Rollup, Node.js, Island Architecture. Content-driven web framework pioneering the Islands Architecture; ships pure semantic HTML by default, selectively hydrating interactive UI components only when visible in viewport.
- [n8n](https://stackitfast.com/project/n8n.md): Fair-Code Workflow Automation & AI Integrator (20+ people, HYBRID) — Stack: TypeScript, Node.js, Vue.js, PostgreSQL, Redis, Docker. Leading self-hosted Zapier alternative; combines an intuitive Vue visual canvas with a high-throughput Node.js execution engine and built-in AI agent reasoning nodes.
- [LangChain](https://stackitfast.com/project/langchain.md): LLM Application Framework & Agent Orchestrator (1M+ MAU, AGENT) — Stack: Python, TypeScript, Pydantic, LangGraph, OpenAI, Chroma. Industry standard for context-aware reasoning; modular chains and LangGraph cyclic graphs allow orchestrating stateful agents with deterministic fallbacks and tool execution.
- [shadcn/ui](https://stackitfast.com/project/shadcn-ui.md): Copy-Paste UI Component Architecture (1M+ MAU, HYBRID) — Stack: React, Tailwind CSS, Radix UI, TypeScript, Lucide. Paradigm shift in design systems; developers own component code directly in their repository without node_modules abstraction lock-in, pairing Radix accessibility with Tailwind.
- [Bun](https://stackitfast.com/project/bun.md): All-in-One JavaScript Runtime & Toolchain (1M+ MAU, CLASSIC) — Stack: Zig, JavaScriptCore, C++, POSIX, TypeScript. Radical reimagining of JS tooling; written from scratch in Zig on WebKit JavaScriptCore for 4x faster module resolution, zero-transpilation TypeScript, and native SQLite speed.
- [FastAPI](https://stackitfast.com/project/fastapi.md): High-Performance Python Web API Framework (1M+ MAU, CLASSIC) — Stack: Python, Starlette, Pydantic, Uvicorn, OpenAPI, Asyncio. Benchmark for modern Python APIs and AI services; pairs Starlette with Pydantic v2 Rust core for ultra-high throughput and automatic interactive documentation.
- [Tailwind CSS](https://stackitfast.com/project/tailwindcss.md): Utility-First CSS Engine & Framework (1M+ MAU, CLASSIC) — Stack: Rust, LightningCSS, TypeScript, Node.js, CSS3. Industry-standard utility styling; modern v4 rewrites the core engine in Rust (Oxide) to scan gigabytes of project files and compile CSS in microsecond render cycles.
- [Next.js](https://stackitfast.com/project/nextjs.md): Fullstack React Framework (1M+ MAU, HYBRID) — Stack: React, Next.js, Rust, TypeScript, Node.js, Tailwind CSS. The enterprise React benchmark; leverages React Server Components, server actions, and a high-performance Rust compiler (Turbopack) for maximum SEO and sub-second page loads.
- [Beszel](https://stackitfast.com/project/beszel.md): Lightweight Server & Container Monitoring (Solo Developer, CLASSIC) — Stack: Go (Agent & Hub), PocketBase / Embedded SQLite, Docker Socket Telemetry, React, Recharts. Ultra-lightweight server resource and Docker container monitoring hub with minimal CPU/RAM footprint. Single-binary Go agents stream CPU, memory, disk I/O, temperature, and container metrics to a central Go/PocketBase hub with interactive React visualizations.
- [PostGraphile](https://stackitfast.com/project/postgraphile.md): Automated GraphQL API Engine (2-5 People, CLASSIC) — Stack: TypeScript, Node.js, Graphile Engine (SQL Planning), PostgreSQL (RLS & LISTEN/NOTIFY), WebSockets. Compiles PostgreSQL database schemas, functions, and Row-Level Security (RLS) policies into an instant, high-performance GraphQL API without N+1 query overhead. Generates optimized single-query SQL execution plans directly from incoming GraphQL ASTs.
- [AppFlowy](https://stackitfast.com/project/appflowy.md): Local-First Privacy Workspace (6-20 People, HYBRID) — Stack: Flutter (UI), Rust (Core Engine), SQLite, WebAssembly, CRDT Yjs. Open-source Notion and Airtable alternative emphasizing complete data ownership and local-first offline execution. Built with Flutter for smooth cross-platform rendering and a high-performance Rust core engine managing CRDT document state and local SQLite persistence.
- [Authelia](https://stackitfast.com/project/authelia.md): Authentication & SSO Proxy Companion (6-20 People, CLASSIC) — Stack: Go, Forward Auth (Nginx/Traefik/Caddy), SQLite / PostgreSQL, Redis (Session Cache), FIDO2 / WebAuthn / TOTP. Zero-trust authentication and authorization server acting as a companion to reverse proxies (Traefik, Nginx, Caddy). Enforces multi-factor authentication (WebAuthn, TOTP, Push) and granular access policies before traffic ever reaches downstream services.
- [SeaweedFS](https://stackitfast.com/project/seaweedfs.md): Distributed Blob & File Storage (2-5 People, CLASSIC) — Stack: Go, Raft Consensus, FUSE Filesystem, S3 API, Hadoop / POSIX Compatibility. Highly scalable distributed file system optimized for billions of small and large files (Haystack + Ficus design). Separates directory metadata from volume servers with Raft consensus, eliminating single-point metadata bottlenecks and achieving O(1) disk lookups.
- [Garage (RustFS)](https://stackitfast.com/project/garage-s3.md): Geo-Distributed Object Storage Engine (2-5 People, CLASSIC) — Stack: Rust, CRDT Metadata, Two-Phase Commit (2PC), RocksDB, S3 API. Lightweight, self-hosted geo-distributed S3-compatible object storage designed to run across multiple data centers and low-bandwidth connections. Uses CRDT metadata replication and RocksDB block storage with minimal memory overhead.
- [QuestDB](https://stackitfast.com/project/questdb.md): Time-Series SQL Database (20+ People, CLASSIC) — Stack: Java (Zero-GC), C++, SIMD Vectorization, InfluxDB Line Protocol, PostgreSQL Wire Protocol. High-performance columnar time-series database engineered for financial tick data, IoT metrics, and real-time telemetry. Uses a zero-garbage-collection Java execution engine with C++ SIMD vectorization and lock-free out-of-order data ingestion.
- [Dragonfly](https://stackitfast.com/project/dragonfly.md): Multi-Threaded In-Memory Key-Value Store (20+ People, CLASSIC) — Stack: C++, Shared-Nothing Architecture, Linux io_uring, Redis Protocol, Memcached Protocol. Next-generation drop-in replacement for Redis and Memcached. Delivers 25x higher throughput and sub-millisecond tail latency by utilizing a modern shared-nothing multi-threaded architecture with Linux io_uring asynchronous I/O and custom memory serialization.
- [LibreChat](https://stackitfast.com/project/librechat.md): Multi-Model AI Agent & Chat Workspace (6-20 People, HYBRID) — Stack: Node.js, Express, MongoDB, Redis, React, Tailwind CSS, TypeScript. Self-hosted AI conversation and autonomous agent workspace supporting all major LLMs (OpenAI, Anthropic, Ollama, HuggingFace). Built with Node.js Express, MongoDB for flexible conversation trees, Redis for rate limiting and streaming buffers, and a responsive React UI.
- [Fasten Health](https://stackitfast.com/project/fasten-health.md): Personal Health Records & Medical EHR Engine (Solo Developer, CLASSIC) — Stack: Go, SQLite, React, TypeScript, Docker, FHIR / SMART-on-FHIR. Self-hosted personal health record aggregator connecting thousands of medical institutions via standard SMART-on-FHIR protocols. Built in Go for secure single-binary local-first deployment with embedded encrypted SQLite storage and zero third-party telemetry.
- [Refine](https://stackitfast.com/project/refine.md): Enterprise Internal Tool & CRUD Framework (20+ People, HYBRID) — Stack: React, TypeScript, TanStack Query, Tailwind CSS, REST / GraphQL Data Providers. Headless React framework designed for rapid development of enterprise internal panels, admin dashboards, and B2B CRUD applications. Decouples business logic, access control (RBAC), and server-state caching (TanStack Query) from UI design system adapters.
- [Browserless](https://stackitfast.com/project/browserless.md): Headless Browser Automation Infrastructure (2-5 People, CLASSIC) — Stack: Node.js, Chromium, Docker, WebSockets, Puppeteer / Playwright, TypeScript. Production-grade headless browser grid for automated web scraping, PDF generation, and synthetic testing. Wraps Chromium instances in isolated Docker sandboxes with WebSocket multiplexing, connection pooling, and memory-leak auto-restarts.
- [Apache Answer](https://stackitfast.com/project/apache-answer.md): Q&A & Developer Knowledge Community (6-20 People, CLASSIC) — Stack: Go, Gin Framework, GORM, PostgreSQL, React, TypeScript, Docker. Self-hosted developer community and technical Q&A platform (Stack Overflow / Dev Community alternative). Built with Go Gin for high concurrency and low memory usage, GORM for multi-database persistence (Postgres/MySQL/SQLite), and React TypeScript for rich Markdown editing.
- [GlitchTip](https://stackitfast.com/project/glitchtip.md): Open-Source Error Tracking & APM (2-5 People, HYBRID) — Stack: Python, Django, PostgreSQL, Celery, Redis, Angular. Lightweight Sentry-compatible application performance monitoring and error tracking platform. Built on Python Django and PostgreSQL with async Celery task queues for high-volume exception ingestion and Redis message buffering.
- [Temporal](https://stackitfast.com/project/temporal.md): Distributed Workflow Orchestrator (20+ People, CLASSIC) — Stack: Go, gRPC, PostgreSQL, Cassandra, Temporal UI (Next.js), TypeScript. Durable execution platform allowing developers to write resilient, long-running distributed workflows in code without worrying about network partitions, crashes, or server restarts. Backed by Go gRPC cluster nodes and persistent event-history replay logs in PostgreSQL/Cassandra.
- [Cosmo (WunderGraph)](https://stackitfast.com/project/cosmo-wundergraph.md): Federated GraphQL API Gateway (6-20 People, HYBRID) — Stack: Go, TypeScript, GraphQL Federation, Redis, ClickHouse, OpenTelemetry. Open-source GraphQL federation gateway and router written in Go. Compiles subgraphs into unified declarative execution plans with sub-millisecond routing overhead, zero-allocation request pipelines, OTEL distributed tracing, and ClickHouse-backed analytics.
- [SurrealDB](https://stackitfast.com/project/surrealdb.md): Multi-Model Real-Time Database (20+ People, CLASSIC) — Stack: Rust, SurrealQL, TiKV / RocksDB, WebAssembly, WebSockets, TypeScript. Unified document, graph, and relational cloud database written in Rust. Replaces complex backend stacks with schema-full/schema-less flexibility, real-time WebSocket live queries, granular row-level permissions, and distributed key-value storage backends (TiKV/RocksDB).
- [Qdrant](https://stackitfast.com/project/qdrant.md): Vector Similarity Search Engine (20+ People, CLASSIC) — Stack: Rust, Tokio, HNSW Graph Index, Memory-Mapped Files (mmap), gRPC / Tonic, RocksDB. Vector database built from scratch in Rust for low-latency similarity search and payload filtering. Utilizes memory-mapped (mmap) disk storage for billion-scale embeddings, custom HNSW graph indexing with hardware SIMD acceleration (AVX-512/NEON), and dual gRPC/REST APIs.
- [OpenObserve](https://stackitfast.com/project/openobserve.md): Cloud-Native Observability Engine (6-20 People, CLASSIC) — Stack: Rust, Apache DataFusion, Apache Parquet, MinIO / S3 Object Storage, Vue, TypeScript. Ultra-low-cost, high-throughput unified observability for logs, metrics, and traces. Written in Rust for zero-overhead stream ingestion, compiling telemetry directly into compressed Apache Parquet columnar shards stored on S3, querying via Apache DataFusion vector execution without maintaining expensive search indices.
- [ElectricSQL](https://stackitfast.com/project/electric-sql.md): Local-First Sync Engine (6-20 People, CLASSIC) — Stack: Elixir, SQLite, PostgreSQL (Logical Replication), TypeScript, CRDT. Local-first architecture moving the network off the critical user interaction path. Elixir actor processes manage Postgres logical replication streams, broadcasting differential "Shapes" to embedded SQLite on client devices with CRDT-based active-active conflict resolution.
- [Stack It Fast](https://stackitfast.com/project/stack-it-fast.md): Content Directory & Showcase (Just Me (Solo Vibe Coder), HYBRID) — Stack: Astro (SSR & Island Architecture), TypeScript, React Islands (Interactive Widgets Hydrated on Demand), Tailwind CSS, Astro Server Endpoints, tRPC v11, Hono / Edge API, PostgreSQL (Supabase / Neon), SQL Migrations, Redis Cache, Cloudflare Pages / Workers (Global Edge CDN), Cloudflare Hyperdrive / Neon Edge, GitHub Actions Automated Pipeline, Turborepo Monorepo Architecture, Strict TypeScript (noImplicitAny, strictNullChecks), Zod Schema-First Input Verification, Playwright Automated E2E Testing. Choose your stack based on real projects, not guesswork. Context: Launch this week as fast as possible driver. Survey verified stack.
- [CopilotKit](https://stackitfast.com/project/copilotkit.md): AI Copilot & Assistant SDK (2-5 people, AGENT) — Stack: TypeScript, React, Next.js, Tailwind, LangGraph, Node.js. React framework for in-app AI copilots; bridges frontend UI state directly into LangGraph agent loops with bidirectional tool execution.
- [Vector](https://stackitfast.com/project/vector.md): Observability Data Router & Telemetry Pipeline (21-100 people, CLASSIC) — Stack: Rust, Tokio, Lua, ClickHouse, Kafka, OpenTelemetry. Ultra-high throughput observability pipeline by Datadog; Rust guarantees minimal memory footprint and zero GC pauses during gigabyte/sec telemetry ingestion.
- [Gatus](https://stackitfast.com/project/gatus.md): Automated Health Dashboard & Status Monitor (solo, CLASSIC) — Stack: Go, Vue.js, SQLite, Postgres, Docker. Lightweight developer status page; compiled into a single binary where Go performs zero-allocation concurrent health checks and serves an embedded Vue interface.
- [Open WebUI](https://stackitfast.com/project/open-webui.md): Self-Hosted AI Interface & Agent Hub (2-5 people, AGENT) — Stack: Python, FastAPI, SvelteKit, TypeScript, SQLite, Ollama, ChromaDB. Extensible OpenAI/Ollama interface; SvelteKit frontend delivers instant responsive streaming while Python FastAPI handles multi-modal RAG and tool calls.
- [Kestra](https://stackitfast.com/project/kestra.md): Declarative Orchestration & Data Flow Engine (6-20 people, CLASSIC) — Stack: Java, Micronaut, Vue.js, Postgres, Kafka, Elasticsearch. Modern Airflow alternative; YAML-based workflow orchestration built on Java Micronaut for microsecond execution overhead and massive horizontal scaling.
- [Immich](https://stackitfast.com/project/immich.md): Photo & Video Management Platform (6-20 people, HYBRID) — Stack: Node.js, TypeScript, SvelteKit, Postgres, pgvector, Redis, Python. High-performance Google Photos alternative; utilizes SvelteKit and NestJS with background Python workers for hardware-accelerated transcoding and facial recognition.
- [Mem0](https://stackitfast.com/project/mem0.md): AI Memory & Context Engine (2-5 people, AGENT) — Stack: Python, FastAPI, Qdrant, Postgres, pgvector, Redis. Universal memory layer for AI agents; extracts and persists structured personal facts and episodic memories across user chat sessions with low latency.
- [Activepieces](https://stackitfast.com/project/activepieces.md): Workflow Automation & AI Orchestration (2-5 people, HYBRID) — Stack: Node.js, TypeScript, Angular, TypeORM, Postgres, Redis. Open-source Zapier alternative; combines an Angular graph UI with Fastify and sandboxed V8 execution workers for high-volume webhook triggers.
- [ToolJet](https://stackitfast.com/project/tooljet.md): Low-Code Developer Tool Platform (6-20 people, HYBRID) — Stack: Node.js, NestJS, React, TypeScript, Postgres, TypeORM. Modular TypeScript ecosystem; NestJS provides a clean dependency-injected backend for connecting enterprise datasources to draggable React interfaces.
- [Appsmith](https://stackitfast.com/project/appsmith.md): Low-Code Internal Tool Platform (21-100 people, CLASSIC) — Stack: Java, Spring Boot, React, TypeScript, MongoDB, Redis. High-throughput internal tool builder; reactive Spring Boot backend proxies database queries securely while browser-side web workers execute user scripts.
- [RustDesk](https://stackitfast.com/project/rustdesk.md): Remote Desktop Infrastructure (6-20 people, CLASSIC) — Stack: Rust, Flutter, Dart, SQLite, WebRTC, Tokio. Ultra-low latency TeamViewer alternative; Rust backend and signaling servers guarantee memory safety and maximum bandwidth efficiency.
- [Authentik](https://stackitfast.com/project/authentik.md): Identity Provider & Access Management (6-20 people, CLASSIC) — Stack: Python, Django, Go, Postgres, Redis, Lit, Docker. Enterprise open source IAM; Django core manages permission trees while lightweight Go outposts terminate TLS and validate tokens at the edge.
- [Flowise](https://stackitfast.com/project/flowise.md): LLM Workflow & Orchestration UI (2-5 people, AGENT) — Stack: Node.js, TypeScript, React, LangChain, TypeORM, SQLite, Postgres. Visual canvas for building and debugging multi-agent LLM workflows; TypeORM handles dynamic agent graph configurations across SQLite or Postgres.
- [Lago](https://stackitfast.com/project/lago.md): Billing & Metering Engine (6-20 people, CLASSIC) — Stack: Rails, Go, Postgres, Redis, ClickHouse, React. Open-source usage-based billing infrastructure; high-throughput Go event ingester paired with Ruby on Rails subscription ledger.
- [Metabase](https://stackitfast.com/project/metabase.md): Business Intelligence Platform (20+ people, CLASSIC) — Stack: Clojure, React, TypeScript, Postgres. Self-service business intelligence and analytics; compiles visual query builder inputs into optimized SQL across 20+ database dialects.
- [NocoDB](https://stackitfast.com/project/nocodb.md): Smart Database Spreadsheet (6-20 people, HYBRID) — Stack: Node.js, Express, Vue, TypeScript, Postgres, MySQL. Transforms any relational database into a collaborative smart spreadsheet with instant REST-APIs and webhooks.
- [Budibase](https://stackitfast.com/project/budibase.md): Internal Tool Builder (6-20 people, CLASSIC) — Stack: Node.js, Svelte, Postgres, Redis, Docker. Low-code platform for internal business apps; Svelte-powered reactive client connected to modular Node.js database connector plugins.
- [Crowd.dev](https://stackitfast.com/project/crowd-dev.md): Developer Data Platform (6-20 people, CLASSIC) — Stack: Node.js, TypeScript, Postgres, Redis, React, Docker. Community intelligence platform; event-driven worker architecture tracks open-source developer engagement across GitHub, Discord, and Slack.
- [Taipy](https://stackitfast.com/project/taipy.md): AI Application Framework (6-20 people, HYBRID) — Stack: Python, React, TypeScript, Flask. Full-stack data science & AI framework; Python business logic binds directly to reactive React frontend components without frontend coding.
- [Penpot](https://stackitfast.com/project/penpot.md): Design & Prototyping Platform (20+ people, CLASSIC) — Stack: Clojure, React, Postgres, Redis, Docker. Open-source web-based Figma alternative; Clojure backend utilizes open SVG standards directly for pixel-perfect design rendering.
- [Strapi](https://stackitfast.com/project/strapi.md): Headless CMS (20+ people, CLASSIC) — Stack: Node.js, TypeScript, React, Postgres, SQLite. Industry-standard headless CMS; customizable content schema engine with auto-generated REST and GraphQL endpoints.
- [Ollama](https://stackitfast.com/project/ollama.md): Local AI Inference Engine (1-5 people, AGENT) — Stack: Go, C++, Docker. Ultra-lightweight local LLM runtime; Go REST daemon manages model distribution while C++/llama.cpp provides optimized GPU compute.
- [Baserow](https://stackitfast.com/project/baserow.md): No-Code Database Platform (6-20 people, HYBRID) — Stack: Python, Django, FastAPI, Postgres, Redis, Nuxt, Vue. Open source Airtable alternative; Django & FastAPI generate dynamic PostgreSQL table schemas per user workspace.
- [Sentry](https://stackitfast.com/project/sentry.md): Error Tracking Platform (20+ people, CLASSIC) — Stack: Python, Django, React, TypeScript, ClickHouse, Postgres, Kafka. Enterprise observability; Django handles transactional models while high-volume event ingestion is streamed via Kafka to ClickHouse.
- [Mage AI](https://stackitfast.com/project/mage-ai.md): Data Pipeline Engine (6-20 people, HYBRID) — Stack: Python, React, TypeScript, Postgres, Docker. Modern data orchestration tool; Python execution engine with interactive React notebook UI for building real-time data pipelines.
- [Logto](https://stackitfast.com/project/logto.md): Identity & Auth Infrastructure (6-20 people, CLASSIC) — Stack: Node.js, TypeScript, Postgres, Redis, React, Docker. Developer-centric OIDC & OAuth identity provider; unified TypeScript backend with fine-grained RBAC and multi-tenancy.
- [Taxonomy](https://stackitfast.com/project/taxonomy.md): Open-Source SaaS Template (1-5 people, AGENT) — Stack: Next.js, React, Tailwind, Prisma, Postgres, TypeScript. The canonical modern open-source Next.js template demonstrating Server Components, shadcn/ui primitives, and Prisma schema modeling.
- [Coolify](https://stackitfast.com/project/coolify.md): Self-Hosted Cloud PaaS (Solo, AGENT) — Stack: Laravel, Livewire, Alpine.js, Tailwind, Docker, Postgres. Self-hosted Heroku/Netlify alternative: single Laravel server orchestrates servers, databases, and Docker containers via SSH.
- [Meilisearch](https://stackitfast.com/project/meilisearch.md): Search Engine (20+ people, CLASSIC) — Stack: Rust, Actix-web, LMDB, WebAssembly. Blazing fast sub-50ms search-as-you-type: custom Rust indexing engine with typo-tolerance out of the box.
- [Directus](https://stackitfast.com/project/directus.md): Headless CMS (20+ people, CLASSIC) — Stack: Node.js, Vue.js, TypeScript, Postgres, Redis, Docker. Database-first architecture: dynamically layers a clean REST and GraphQL API directly over any existing SQL schema.
- [Hoppscotch](https://stackitfast.com/project/hoppscotch.md): API Testing Client (6-20 people, CLASSIC) — Stack: Vue.js, Nuxt, Node.js, GraphQL, Postgres, Tailwind. Lightweight open-source Postman alternative: runs directly in browser with offline PWA capabilities.
- [Langfuse](https://stackitfast.com/project/langfuse.md): LLM Observability (6-20 people, AGENT) — Stack: Next.js, ClickHouse, Postgres, Prisma, Turborepo, Docker. Specialized LLM tracing platform: high-volume generation logs streamed into ClickHouse for cost and latency analytics.
- [Plausible Analytics](https://stackitfast.com/project/plausible.md): Privacy Web Analytics (2-5 people, CLASSIC) — Stack: Elixir, Phoenix, ClickHouse, Postgres, Tailwind. BEAM concurrency engine handles massive ingestion surges with minimal memory footprint into ClickHouse.
- [Chatwoot](https://stackitfast.com/project/chatwoot.md): Customer Support Suite (6-20 people, HYBRID) — Stack: Rails, Vue.js, Postgres, Redis, Sidekiq. Omnichannel real-time support inbox connecting WhatsApp, Twitter, Email, and Webchat over WebSockets.
- [PocketBase](https://stackitfast.com/project/pocketbase.md): Embedded Backend (Solo, CLASSIC) — Stack: Go, SQLite, Echo Framework, Svelte. Ultra-compact single binary: zero microservice maintenance overhead, handles 10,000+ RPS on a $5/mo VPS.
- [Starlight](https://stackitfast.com/project/starlight.md): Documentation Portal (Solo, CLASSIC) — Stack: Astro, TypeScript, Tailwind CSS, MDX, Pagefind. Pure zero-JS static baseline with blazing 100/100 Lighthouse scores and client-side WASM search indexing.
- [Typebot](https://stackitfast.com/project/typebot.md): Conversational Form Builder (Solo, AGENT) — Stack: Next.js, Prisma, Postgres, Tailwind, Docker. Visual node-based builder: drag-and-drop state machine with lightweight web embed runtime.
- [AFFiNE](https://stackitfast.com/project/affine.md): Collaborative Workspace (6-20 people, HYBRID) — Stack: React, Rust, Yjs, NestJS, Postgres, SQLite. Local-first collaborative workspace: CRDT conflict-free resolution in Rust with peer-to-peer sync engine.
- [PostHog](https://stackitfast.com/project/posthog.md): Product Analytics Platform (20+ people, HYBRID) — Stack: Django, React, ClickHouse, Postgres, Kafka, Redis. Billions of events/month: ingest through Kafka into ClickHouse columnar storage while keeping UI on Django/Postgres.
- [Appwrite](https://stackitfast.com/project/appwrite.md): Backend-as-a-Service (20+ people, CLASSIC) — Stack: Docker, PHP, Swoole, MariaDB, Redis, Svelte. Self-contained asynchronous BaaS: async Swoole server delivers ultra-low memory footprint and massive concurrency.
- [Papermark](https://stackitfast.com/project/papermark.md): Document Analytics SaaS (Solo, AGENT) — Stack: Next.js, Prisma, Postgres, Tailwind, Tinybird, AWS S3. Modern open-source DocSend alternative built entirely on serverless Next.js, S3, and real-time event ingestion.
- [Dify.ai](https://stackitfast.com/project/dify.md): LLM App Builder (20+ people, AGENT) — Stack: Next.js, Python, Flask, Celery, Postgres, pgvector, Redis. High-throughput AI pipeline: visual canvas frontend with Python worker cluster for asynchronous LLM orchestration.
- [Infisical](https://stackitfast.com/project/infisical.md): Secret Management (6-20 people, HYBRID) — Stack: Node.js, Express, Postgres, Redis, React, Tailwind. Zero-knowledge end-to-end encryption architecture: secrets decrypted on client machine before runtime injection.
- [Trigger.dev](https://stackitfast.com/project/trigger-dev.md): Job Queue / Dev Tool (6-20 people, HYBRID) — Stack: Remix, Postgres, Redis, Zod, Docker. Long-running jobs: durable execution layer completely decoupled from web servers.
- [Formbricks](https://stackitfast.com/project/formbricks.md): Survey & Feedback SaaS (2-5 people, AGENT) — Stack: Next.js, Prisma, Postgres, Turborepo. Embeddable widget and admin portal in the same repo: agents make end-to-end changes in one context.
- [Bluesky App](https://stackitfast.com/project/bluesky-app.md): Mobile App (20+ people, CLASSIC) — Stack: React Native, Expo, TypeScript, Go. Single codebase for two app stores; protocol server scales as an independent Go service.
- [OpenBB](https://stackitfast.com/project/openbb.md): Financial Data Platform (6-20 people, HYBRID) — Stack: Python, FastAPI, Pandas, Pydantic. Dozens of data provider adapters: schema validation is a core product requirement.
- [Maybe](https://stackitfast.com/project/maybe.md): Personal Finance (2-5 people, AGENT) — Stack: Rails, Hotwire, Postgres, Sidekiq. Convention-heavy framework: AI agents predict file locations accurately, generating fewer bugs.
- [Documenso](https://stackitfast.com/project/documenso.md): E-signature SaaS (2-5 people, AGENT) — Stack: Next.js, tRPC, Prisma, Postgres, Tailwind. Small team, agent-assisted workflow: unified language and strong type inference verify generated code.
- [Novu](https://stackitfast.com/project/novu.md): Notification Infra (6-20 people, HYBRID) — Stack: NestJS, MongoDB, Redis, BullMQ, React. Queue-centric architecture: workers scale independently from API, delivery guarantees in queue.
- [Ghost](https://stackitfast.com/project/ghost.md): Content Platform (20+ people, CLASSIC) — Stack: Node.js, Ember, MySQL, Handlebars. Long-lived content product: theme compatibility and version stability prioritize over new tech.
- [Twenty](https://stackitfast.com/project/twenty.md): CRM SaaS (6-20 people, HYBRID) — Stack: NestJS, GraphQL, React, Postgres, Recoil. User-defined data model requires schema-flexible GraphQL layer that changes at runtime.
- [Medusa](https://stackitfast.com/project/medusa.md): E-commerce API (20+ people, CLASSIC) — Stack: Node.js, Express, Postgres, MikroORM, Redis. Plugin-based commerce core: payment and shipping modules versioned independently from core.
- [Umami](https://stackitfast.com/project/umami.md): Web Analytics (Solo, HYBRID) — Stack: Next.js, Prisma, Postgres, ClickHouse. Solo developer, fast MVP: single framework, single deploy target, optional ClickHouse for scale.
- [Plane](https://stackitfast.com/project/plane.md): Project Management (6-20 people, CLASSIC) — Stack: Django, Next.js, Postgres, Redis, Docker. Heavy workflow and permission logic in a mature Python backend; frontend is a pure presentation layer.
- [Dub](https://stackitfast.com/project/dub.md): Link & Analytics SaaS (2-5 people, HYBRID) — Stack: Next.js, Tinybird, Upstash, Prisma, PlanetScale. Thousands of click events per second: analytics offloaded to an OLAP service, OLTP kept lean.
- [Excalidraw](https://stackitfast.com/project/excalidraw.md): Canvas Editor (2-5 people, CLASSIC) — Stack: React, Vite, Canvas API, Firebase. Client-heavy drawing engine; server is only a lightweight layer for sharing and persistence.
- [Cal.com](https://stackitfast.com/project/cal-com.md): Scheduling SaaS (6-20 people, CLASSIC) — Stack: Next.js, Turborepo, tRPC, Prisma, Postgres. Self-hostable SaaS: web, embed, and API packages in a single monorepo with type-safe boundaries.

## Architectural Standards & Non-Negotiables
When scaffolding codebases based on STACK IT FAST architectures, adhere to these fundamental principles:
1. Monorepo Isolation: Structure projects with clean package boundaries (apps/web, packages/ui, packages/db, packages/config).
2. Zero Any Policy: Enforce strict TypeScript compilation (strict: true, noImplicitAny: true) and runtime Zod validation on all API boundaries.
3. Design Tokens: Utilize dark-theme palette (#0e0e0f bg, #141416 surface, crisp 1px borders) with IBM Plex typography.
4. Data Integrity: Declarative Drizzle/Prisma models with foreign keys, relational indices, and serverless connection pooling.