codeintel.xyz / stack

Infrastructure Stack Reference

Eight tiers, 46 technologies, one decision framework. Every entry answers the only question that matters: do you need it, and when?

8 tiers46 entries10 in production uselast reviewed September 2026
persona:

Static / Frontend

5 entries

Astro

USED

Ship content-heavy sites with near-zero JS while still using components.

need it when
Blog, docs, marketing site, or anything where SEO and load speed matter more than app-like interactivity.
skip it
You're building a dashboard or highly interactive app — reach for a SPA framework instead.
Open SourceFree
48k

Cloudflare Pages / Workers

USED

Deploy static and edge-compute sites globally without managing servers.

need it when
You want free-tier-friendly global deploys with edge functions and fast cold starts.
skip it
You need long-running processes or heavy GPU workloads — edge runtime won't fit.
ManagedFree

Tailwind CSS

Style consistently without writing ad-hoc CSS or maintaining a design system from scratch.

need it when
Any project where you want utility-first styling and small production CSS.
skip it
Design-heavy marketing work with a dedicated designer handing off full CSS.
Open SourceFree
85k

htmx

Add dynamic partial updates to server-rendered pages without a JS framework.

need it when
Server-driven apps that need interactivity but you refuse a node build pipeline.
skip it
Complex client state, offline support, or heavy animation.
Open SourceFree
43k

Alpine.js

Sprinkle client-side behavior (dropdowns, toggles, tabs) onto server-rendered HTML.

need it when
Small interactive islands inside otherwise-static pages.
skip it
Anything with routing, shared state, or >200 lines of client logic.
Open SourceFree
28k

Data / Storage

6 entries

SQLite

USED

Persist structured data without operating a database server.

need it when
Single-node apps, prototypes, embedded analytics, or anything under ~10 concurrent writers. It's the default answer.
skip it
Multi-region writes or genuinely high concurrent write volume.
Open SourceFree
— (bundled, ~6M LOC C)

Cloudflare R2

USED

Store blobs and files without egress fees eating your margin.

need it when
Object storage for uploads, backups, model artifacts, or static assets — zero egress cost is the hook.
skip it
You're all-in on AWS and S3 egress doesn't matter at your scale.
ManagedFree

Turso / libSQL

Distributed SQLite with replicas at the edge.

need it when
You want SQLite ergonomics but need read replication or a hosted story.
skip it
Simple single-server apps — plain SQLite is simpler.
Open SourceManaged
10k

PostgreSQL

The default relational database when you need real concurrency, extensions, and a long future.

need it when
Multi-tenant SaaS, complex queries, JSONB workloads, or anything you expect to live 10 years.
skip it
Single-node tools where SQLite suffices — don't run a server you don't need.
Open SourceFree
17k

Redis / Valkey

Cache hot data, rate-limit, and coordinate workers with sub-millisecond latency.

need it when
Session storage, caching layers, queues under load, leaderboards.
skip it
You'd be adding a network hop to save 5ms — SQLite in WAL mode may be enough.
Open SourceFree
68k

DuckDB

Run analytical SQL directly over Parquet/CSV files without a warehouse.

need it when
Local analytics, log analysis, embedding dumps, ad-hoc data exploration.
skip it
OLTP workloads — it's columnar and built for scans, not transactions.
Open SourceFree
28k

Auth

5 entries

Clerk

Ship complete auth (sessions, MFA, orgs, SSO) without becoming an auth engineer.

need it when
SaaS products where auth is table stakes and you'd rather build the product. Orgs/multi-tenancy out of the box.
skip it
Deep customization needs, strict data-residency rules, or you want zero vendor lock on identity.
ManagedFree

Auth.js (NextAuth)

OAuth/session auth that lives in your app, not a vendor's cloud.

need it when
JS/TS apps where you want provider logins with full control and no external dependency.
skip it
Non-JS backends or when you need enterprise SSO on day one.
Open SourceFree
26k

Keycloak

Self-hosted identity with SAML, OIDC, and enterprise federation.

need it when
Compliance-driven environments, on-prem requirements, or B2B SSO at scale.
skip it
Solo projects and MVPs — its operational weight will bury you.
Open SourceSelf-Host
27k

WorkOS

Add enterprise SSO/SCIM to an existing app without rebuilding auth.

need it when
You're selling to companies whose IT departments demand SAML and directory sync.
skip it
Pre-enterprise-stage products — it's a later-layer purchase.
Managed

Lucia (pattern)

Roll minimal session auth with plain primitives — no framework magic.

need it when
You understand auth and want ~200 lines of readable session code you fully own.
skip it
You want OAuth providers handled for you — use Auth.js instead.
Open SourceFree
10k

Backend / API

6 entries

Hono

USED

Ultra-light, fast HTTP framework that runs on any JS runtime (Workers, Node, Bun, Deno).

need it when
APIs on Cloudflare Workers or anywhere cold starts matter. The default choice for this stack.
skip it
You need a batteries-included framework with ORM, auth, and admin built in.
Open SourceFree
23k

FastAPI

Typed Python APIs with automatic OpenAPI docs and first-class async.

need it when
ML/AI services, data pipelines exposed as APIs, or any Python-heavy backend.
skip it
Pure JS shops — Hono covers the same ground.
Open SourceFree
78k

Drizzle ORM

Type-safe SQL query building without a heavy runtime or query-engine binary.

need it when
TypeScript apps where you want SQL-shaped APIs and migrations that don't fight you.
skip it
Rapid prototyping where Rails-style magic outweighs control.
Open SourceFree
30k

tRPC

End-to-end typed APIs without writing a schema layer or codegen step.

need it when
Full-stack TypeScript monorepos where client and server share types naturally.
skip it
APIs consumed by non-TS clients or third parties — use REST/OpenAPI.
Open SourceFree
36k

Go (net/http / stdlib)

Single-binary backends with predictable performance and minimal dependencies.

need it when
CLI-adjacent services, high-throughput proxies, or anything you deploy as one static binary.
skip it
You live in Python/TS land and velocity matters more than binary size.
Open SourceFree

Railway / Fly.io

Deploy containers and full backends without building a platform team.

need it when
You've outgrown serverless or need long-running processes, queues, and persistent volumes.
skip it
Static + edge is enough — Cloudflare covers it cheaper.
ManagedFree

Search / CMS

5 entries

Pagefind

USED

Full-text search for static sites, generated at build time, zero server.

need it when
Docs sites and blogs with hundreds to thousands of pages. Ships a chunked index loaded on demand.
skip it
Dynamic content or user-generated data — you need a live index.
Open SourceFree
14k

Ghost

USED

Publishing platform with memberships, newsletters, and a real editor out of the box.

need it when
A blog/publication where writing workflow matters more than building one from markdown files.
skip it
Docs or product content that belongs in your repo and version control.
Open SourceManagedSelf-Host
48k

Meilisearch

Fast, typo-tolerant search you can self-host in minutes.

need it when
Product search, docs search, or any dataset under a few million docs with instant results.
skip it
Complex relevance engineering or huge corpora — that's Elasticsearch/Tantivy territory.
Open SourceSelf-HostManaged
49k

Tantivy

Full-text search engine library in Rust — embed search in your own binary.

need it when
You want Lucene-class search without JVM ops, embedded in your service.
skip it
You want a turnkey server — use Meilisearch.
Open SourceFree
13k

MDX / Content Collections

Keep content in the repo, type-checked and version-controlled.

need it when
Docs, changelogs, and technical writing that belongs next to the code.
skip it
Non-technical authors need a WYSIWYG editor — use Ghost or a headless CMS.
Open SourceFree

Observability

5 entries

GoatCounter

USED

Privacy-friendly page analytics without cookie banners or surveillance pricing.

need it when
Blogs and small sites where you want honest traffic counts and nothing creepy.
skip it
Funnel/behavior analytics for a product — you need event-based tooling.
Open SourceFreeSelf-Host
5k

Grafana + Prometheus

Metrics collection and dashboards that are the industry default.

need it when
Any server infrastructure you operate yourself. Start here before buying anything.
skip it
Serverless-only stacks — you'll get more from provider-native logs/metrics.
Open SourceSelf-HostFree
67k / 57k

OpenTelemetry

Vendor-neutral tracing/metrics/logs instrumentation you won't have to rip out later.

need it when
Distributed systems where you need cross-service traces. Instrument once, export anywhere.
skip it
Single-service apps with log-based debugging — don't over-instrument.
Open SourceFree
— (multi-repo)

Sentry

Error tracking with stack traces, release correlation, and alerting.

need it when
Any production app with real users. The first hour of setup pays for itself forever.
skip it
Honestly, almost never — the free tier covers most small projects.
Open SourceManagedSelf-Host
40k

Axiom

Serverless-native log analytics with generous free tier and fast full-text queries.

need it when
High-volume logs from edge/serverless functions where traditional log tools cost too much.
skip it
You already run Grafana/Loki and it's working.
ManagedFree

AI / Agent Frameworks

6 entries

LangGraph

Build stateful, graph-structured agent workflows with checkpointing and human-in-the-loop.

need it when
Multi-step agents with branching logic, retries, and durable state you need to inspect.
skip it
Single-prompt LLM calls — a framework here is pure overhead.
Open SourceFree
13k

Pydantic AI

Type-safe agent framework built on Pydantic — structured outputs without string parsing.

need it when
Python teams that want agent logic with real validation and dependency injection.
skip it
JS/TS shops or graph-heavy workflows — LangGraph fits better.
Open SourceFree
10k

Vercel AI SDK

Streaming LLM UI primitives and provider abstraction for TypeScript apps.

need it when
Chat/streaming interfaces in React/Next with multi-provider model switching.
skip it
Backend-only pipelines with no streaming UI.
Open SourceFree
14k

Instructor

Extract structured data from LLM outputs with retries and validation.

need it when
Any pipeline where the LLM must return valid, schema-conformant JSON.
skip it
You've moved to a framework with native structured outputs.
Open SourceFree
10k

LiteLLM

One OpenAI-shaped interface over 100+ providers, with proxying, budgets, and fallbacks.

need it when
Multi-provider routing, cost controls, or dropping in new models without code changes.
skip it
Single-provider apps — call the SDK directly.
Open SourceFree
—

Hermes Agent

USED

First-party agent runtime for this stack: tool-calling loop with durable state on SQLite.

need it when
You want a minimal, inspectable agent loop you fully own — no framework lock-in, contract-testable.
skip it
You need a large ecosystem of prebuilt integrations — use LangGraph.
Open SourceSelf-Host

Agent Infrastructure / Orchestration

8 entries

MCP (Model Context Protocol)

USED

Standard protocol connecting models to tools, resources, and data sources.

need it when
You're building agents that need to interoperate with a growing ecosystem of tool servers.
skip it
Single-app tool calling — plain function calling is simpler.
Open SourceFree

MCP Supply-Chain Security

Tool descriptions are attacker-controlled input — they can steer an agent, leak context, or trigger unintended actions.

need it when
You run agents that connect to third-party MCP servers. Pin the trust boundary: allow-list servers, validate descriptions, treat every tool call as an input-validation gate.
skip it
You only call first-party tools you wrote yourself behind a stable interface.
FreeSecurityPrompt-InjectionTrust

Temporal

Durable workflow execution: code that survives crashes, retries, and multi-day processes.

need it when
Long-running agent pipelines, billing flows, or anything where 'the process died mid-way' is unacceptable.
skip it
Short-lived request/response work — a queue is enough.
Open SourceSelf-HostManaged
13k

Firecracker / gVisor

Run untrusted agent-generated code in hardened microVMs or sandboxes.

need it when
Agents that execute code. Non-negotiable isolation layer before anything else.
skip it
Never for agent code execution — if you're skipping this, you're skipping safety.
Open SourceSelf-HostFree
27k / 16k

E2B

Managed sandboxes for running AI-generated code with SDK access.

need it when
You need agent code execution now and don't want to operate Firecracker yourself.
skip it
High-volume execution where per-second sandbox billing dominates costs — self-host.
ManagedFreeOpen Source

pgvector

Vector similarity search inside PostgreSQL — embeddings without new infrastructure.

need it when
RAG under ~10M vectors where you want one database for everything.
skip it
Billion-scale retrieval or heavy ANN tuning — dedicated vector DBs pull ahead.
Open SourceFree
14k

Qdrant

Purpose-built vector database with filtering, quantization, and distributed sharding.

need it when
Large-scale semantic search or hybrid filtering over embeddings at production volume.
skip it
Small RAG apps — pgvector in your existing Postgres is the right boring answer.
Open SourceSelf-HostManaged
23k

Celery / BullMQ

Background job queues for work that shouldn't block a request.

need it when
Email, embedding generation, webhooks, scheduled tasks — anything async.
skip it
Durable multi-step workflows — upgrade to Temporal before you outgrow queues painfully.
Open SourceFree
26k / 16k

Expansion Candidates

reviewed September 2026

L3 · Auth — open gaps

  • Passkeys-first flow. Current entries are OAuth/session oriented; WebAuthn-native onboarding is untested in this stack. Candidate: a thin passkey layer over Lucia-style sessions.
  • Machine-to-machine auth. Agent-to-agent and agent-to-API authentication (mTLS, scoped tokens) has no first-class entry yet. This matters more as L8 grows.
  • Authorization (not authentication). Nothing here handles fine-grained permissions — Oso/OpenFGA-class tooling is the known gap.

L4 · Backend — expansion ideas

  • Queue-native runtime. Cloudflare Queues vs. self-hosted BullMQ needs a head-to-head under real agent workload shapes.
  • Rust sidecar layer. Hot-path components (embedding rerank, token counting) as Rust binaries called over UDS — evaluation pending.
  • API gateway. Rate limiting and key management for multi-tenant AI endpoints is currently ad hoc. Candidate: standalone gateway or Hono middleware consolidation.

Gaps are reviewed quarterly. Last pass: September 2026. Nothing was promoted this cycle — all candidates still in evaluation.

```