Config Complexity Score
How many files and lines of config before you write actual code?
Zero config. Write a function in the browser, it's deployed. Environment variables added in val settings. No local files whatsoever.
Zero config files. Download binary, run it. Admin UI for everything.
Almost zero config. create hono scaffolds everything. Runtime-specific deploy config is separate.
One DATABASE_URL env var. No config files. Dashboard handles provisioning, branching, and compute scaling.
Zero config out of the box — opinionated defaults. biome.json only needed to override rules. Replaces ESLint + Prettier with one tool.
Drop-in Node replacement. No config required for most projects. bunfig.toml only for registry or test overrides.
Two env vars: REST URL + token. No client config. Works globally via HTTP — no connection pooling, no persistent connections to manage.
One API key. DNS verification in dashboard. SDK is 5 lines. Possibly the lowest config overhead of any email provider.
Zero config. Drop React components in emails/ folder. Dev server starts with one command. Build output is plain HTML.
create elysia gives you a working server in 10 lines. Plugin system needs no config files. Bun-native, so no bundler setup.
No config. Import and define schemas in TypeScript. Zero setup overhead — works in any project with TypeScript.
Same as Zod: import and use. Tree-shakeable by design. No config, no code gen, no CLI. The anti-ceremony validation library.
QueryClient + QueryClientProvider. That is it. Devtools are an optional import. No external service or env vars.
Zero config. create() returns a hook. Middleware (persist, devtools) are optional imports.
Zero config if you already use Vite — just add test.globals to vite.config.ts. Separate vitest.config.ts only needed for advanced coverage or environment setup.
v4 requires zero config — CSS @import is the entire setup. v3 needs a tailwind.config.ts but defaults are sensible. Content paths are the only required setting.
create elysia gives you a working server in 10 lines. Plugin system needs no config files. Bun-native so no bundler setup.
Zero config files. Download binary, run it. Admin UI for everything.
Zero config. Drop React components in emails/ folder. Dev server starts with one command. Build output is plain HTML.
No config. Import validators and schemas in TypeScript. Tree-shakeable by design — zero config, zero ceremony, works anywhere.
Zero config. create() returns a hook. Middleware (persist, devtools) are optional imports.
QueryClient + QueryClientProvider. That is it. Devtools are an optional import. No external service or env vars.
One API key in env. OpenAI-compatible API means existing OpenAI SDK config works. No client config files needed.
Install and sign in. Workflows saved in cloud. Theme customization is YAML. No project-level config needed. Settings are GUI-driven.
Zero config framework. No hono.config needed. TypeScript config is standard. Middleware added in code. Deployment config depends on target (wrangler.toml for CF, none for Bun).
No framework config file. Everything is code — plugins, validation, routes. TypeScript config is the only requirement. Bun runtime needs no extra config.
CEREBRAS_API_KEY in env. Use OpenAI SDK with base URL. No config files. Dashboard only for key management.
GROQ_API_KEY in env. OpenAI-compatible API. No config files. GroqCloud console for key and usage.
TOGETHER_API_KEY in env. OpenAI-compatible SDK. No config files. Dashboard for fine-tuning and model management.
OPENROUTER_API_KEY in env. Use OpenAI SDK with openrouter.ai base URL. No config. Dashboard for credits and usage.
Zero config. new PGlite() in code. No server, no env vars, no config files. Extensions loaded via import. The simplest Postgres setup possible.
Zero config for embedded search. Schema defined in code. Orama Cloud adds env vars for sync — but local search needs nothing.
No config files. Write code in browser or via API. Environment variables set in dashboard per val. No build step, no deployment config.
Minimal. One middleware file + 2 env vars. Dashboard does the heavy lifting.
Auto-detects everything. Optional railway.toml for custom build/start commands.
Database URL + auth token in env. CLI handles creation. Embedded replica config adds a few lines to your app code.
Client init is 5 lines. Functions defined in code. Dev Server auto-discovers. Cloud needs event key + signing key.
npx convex dev generates everything. Schema in convex/schema.ts. Functions in convex/ folder. Almost zero manual config.
15-line Caddyfile does what 80 lines of nginx.conf does. Automatic HTTPS. Simplest reverse proxy config that exists.
One YAML to bind project/config. All secrets managed in dashboard. Replaces .env files entirely. CLI injects at runtime.
Sensible defaults out of the box. Config grows with plugins but base setup is minimal. The anti-Webpack.
deno.json is simple but URL-based imports are unfamiliar. No node_modules means different mental model. Deploy target config is separate.
API key + dataset name. SDK auto-instruments. Next.js integration is one wrapper in next.config.js. Ingest pipeline config lives entirely in dashboard.
API key + host. posthog.init() in one file. Feature flags, session recording, funnels all configured in dashboard. No local config files.
mint.json defines navigation, colors, and settings. MDX files for content. GitHub-connected deploy. Config is JSON — simple but grows with navigation structure.
svelte.config.js is concise. Adapter-based deploy is one line. No separate TypeScript config needed. Zero overhead for adding SSR or static output.
Two boilerplate files to initialize. No schema files, no code generation — types flow from server to client automatically. Zero external config.
Type-safe SQL query builder with minimal init. No schema file, no migrations CLI — bring your own. Schema types written manually or generated from DB.
components.json tracks your config. One-time tailwind setup. Each component is installed as source code — no runtime dependency config needed.
Middleware plus two env keys. App Router setup is one ClerkProvider import. Dashboard handles user management and email templates.
drizzle.config.ts points at schema and database. push or migrate workflow your choice. Schema is plain TypeScript — no DSL to learn.
API key in env. Dashboard for workspace and domain. SDK is one import. Open-source variant adds Docker compose for self-hosting.
Zero config to start — install and login. Optional .cursorrules for project context. MCP servers configured in settings JSON.
npm create vite scaffolds working app. Plugin imports are one line each. No build orchestration needed for typical SPA.
playwright.config.ts is auto-generated by init command. Browser, baseURL, and reporters configured there. Trace and screenshot settings add lines but are optional.
Route tree is auto-generated from file structure. No manual config. Vite plugin enables codegen. Type-safe routing with zero config overhead.
Environment key in env. flagsmith.init() call in code. Feature flags and remote config defined entirely in dashboard. No local config files required.
One route handler file defines upload endpoints. One API key. Framework-specific adapter is one import. Simplest file upload setup available.
Define your DB interface type, create a Kysely instance with a dialect, done. No schema file, no migrations CLI out of the box — flexibility at the cost of ceremony.
svelte.config.js is concise. Adapter-based deploy is one line. No separate TypeScript config needed. Zero overhead for adding SSR or static output.
components.json tracks your config. One-time tailwind setup. Each component is installed as source code — no runtime dependency config needed.
deno.json for imports and tasks. GitHub-connected deploy needs no config file. Env vars in dashboard. KV just works with no setup.
Provider API key in env. One file to create provider instance. Route handlers or server actions wire it together. No dashboard config.
Root key in env. API and key configuration in dashboard. SDK is one import with no config object. Rate limiting rules set per-key in dashboard.
One YAML to bind project/config. All secrets managed in dashboard. Replaces .env files entirely. CLI injects at runtime.
Optional depot.json for project binding. Existing Dockerfile is all that's needed. CI integration is one env var (DEPOT_TOKEN) and swapping docker build for depot build.
npx convex dev generates config. Schema in convex/schema.ts. Functions in convex/ directory. Dashboard for env vars and deployment. Minimal file config.
Just TURSO_DATABASE_URL and TURSO_AUTH_TOKEN in env. turso CLI for database management. No config files needed. Embedded replicas add one flag to client init.
DUB_API_KEY in env. Domain configuration in dashboard. SDK init is one line. Workspace settings are dashboard-only.
Docker Compose with Postgres. Env vars for DB, secrets, SMTP. No app-level config files. Everything managed through web UI after setup.
LANGFUSE_PUBLIC_KEY, SECRET_KEY, HOST in env. SDK init wraps existing LLM calls. Dashboard for project setup. Self-hosting adds Docker + Postgres + ClickHouse.
Client init and serve handler — two files. Functions defined alongside your code. inngest dev for local. Cloud keys in env for production. Minimal config.
One config file. supabase init does the rest. RLS policies in SQL, not a DSL.
Almost zero file config. Most setup is in the Stripe dashboard + webhook URL.
Schema file is the entire config. One DATABASE_URL env var. Migrations generated automatically.
Schema in TS, config in TS — no DSL to learn. drizzle-kit handles migrations. Zero dashboard steps.
Config file for project settings and integrations. CLI init scaffolds everything. Tasks defined in code, no extra config per task.
One connection string env var. All config in Atlas dashboard: network access, users, indexes. Dashboard does the work but has many screens.
Serverless CockroachDB: one connection string, Postgres-compatible. Self-hosted: multi-node config is enterprise-grade complexity.
App Platform auto-detects most things. Optional app.yaml for IaC. Dashboard-driven setup is straightforward.
SDK key + client-side key. Flag definitions live in dashboard. Server/client SDK config differs. Multi-environment setup requires dashboard-side work.
astro.config.mjs is clean and minimal. Integration system is plug-and-play. Adapters (Vercel, Netlify, Node) are one line. Islands architecture needs no special config.
Vite-based Remix is lean. File-based routing needs no config. Adapter for deploy target is one npm install. Legacy remix.config.js is more verbose.
Two TypeScript files plus env vars. No dashboard. Database adapter and provider config inline. Plugins are added by import — typed end-to-end.
Project keys in env. Dashboard for redirect URLs and email templates. SDK handles passwordless flows. Setup scales with auth methods enabled.
Access token plus webhook secret. Dashboard for products and benefits. Checkout sessions created server-side. Indie-friendly setup.
modal token new authenticates. App, volumes, secrets, and schedules all defined in Python decorators. Deploy via modal deploy.
cypress.config.ts for base URL, timeouts, and plugins. Component testing adds a dev server config block. Heavier than Playwright config but still manageable.
Heroku-compatible. Buildpacks auto-detect most configs. Procfile for custom start commands. Config managed via dokku config:set CLI.
Schema file defines models, auth, and resolvers. grafbase dev uses it directly. Deploy connects to GitHub. Env vars for secrets.
One auth config file with providers, adapters, plugins. No dashboard — everything in code. Database adapter adds schema setup. Clean and composable.
StackProvider config is minimal. OAuth providers configured in dashboard. Env vars for project ID and keys. Less config than Clerk.
drizzle.config.ts points to schema and connection. Schema-as-code in TypeScript. drizzle-kit handles migrations. Clean separation of config and schema.
Router setup and context creation. No external config file — everything is TypeScript. Framework adapter adds one file (e.g., [...trpc].ts for Next.js).
API key and webhook secret in env. Products and pricing configured in dashboard. SDK init is one line. Webhook endpoint needs route setup.
mint.json for navigation, colors, logo. MDX files for content. OpenAPI spec for auto-generated API ref. Git-based deployment — push and it builds.
trigger.config.ts for project binding and runtime settings. Tasks defined in trigger/ directory. Dev server connects to cloud for orchestration. Clean setup.
Minimal for basic setup. Grows with rewrites, headers, middleware config.
3 config files for Next.js. Wizard helps but manual adjustments always needed.
wrangler.toml handles most config. Bindings (KV, D1, R2) add complexity.
turbo.json pipeline config is simple for basic cases. Caching inputs/outputs and env passthrough need care.
Cloud version: just env vars. Self-hosted: docker-compose with 20+ containers. appwrite.json for CLI deployments.
nuxt.config.ts grows quickly with modules. Each Nuxt module (image, i18n, auth) adds its own config block. Auto-imports remove boilerplate but debugging can be tricky.
SDK key in env. Splits defined in dashboard. Traffic types, segments, and rollout rules require dashboard-side setup before SDK can be used. More enterprise-oriented than LaunchDarkly.
AuthKit handles flows. Dashboard configures Connections per organization. SSO setup requires IdP-side config too — adds steps but unavoidable for enterprise.
API key plus webhook signing secret. Dashboard for store, products, and variants. Tax handling is a major plus. Webhook event types are numerous.
API keys in env. Workflows defined in dashboard or via knock CLI. Channels (email/SMS/push) need provider credentials added per channel.
Token in env. Data sources and pipes as files committed to repo. tb push deploys. Schema definitions and SQL transformations live in source control.
Two config files auto-generated by init. main.ts for framework, addons, and Vite overrides. preview.ts for global decorators and parameters. Addon configs add more lines.
API key plus webhook signing secret. Dashboard for store, products, and variants. Tax handling is a major plus. Webhook event types are numerous.
Cloud version: just env vars. Self-hosted: docker-compose with 20+ containers. appwrite.json for CLI deployments.
One TypeScript file defines your entire AWS infrastructure. No YAML, no JSON, no HCL. Grows with stack complexity but stays readable.
Token in env. Data sources and pipes as files committed to repo. tb push deploys. Schema definitions and SQL transformations live in source control.
Self-hosting needs Docker Compose with multiple services. Cloud version is simpler — just API key and host URL. Worker config in code.
Standard Docker knowledge required. Coolify UI simplifies deploy but Dockerfile is on you.
Tenant setup in dashboard takes time. Applications, APIs, rules/actions, and social connections all need separate config.
New flat config is cleaner than .eslintrc but ecosystem plugins are still migrating. Manual parser and plugin wiring required.
fly launch generates fly.toml. Docker-based deploys need a Dockerfile. Secrets managed via CLI, not files.
Schema-as-code is powerful but verbose. Studio config file grows with plugins. GROQ query language has its own learning curve.
payload.config.ts is TS-first and type-safe, but grows fast. Collections, globals, plugins, email, and DB adapter all defined there. No dashboard setup — everything is code.
Many env vars for integrations (Google, Stripe, email). Self-hosting is complex. Managed version is simpler — just dashboard config.
Sync service needs Docker alongside Postgres. Shape definitions in code. Database DDL for ENABLE ELECTRIC. No dashboard — all config in code and env.
project.json per package adds up quickly in large monorepos. Executors and generators are powerful but require understanding the abstraction.
Content model built entirely in dashboard. 4 env vars (space ID, delivery token, preview token, management token). Migration scripts are optional but recommended.
Multiple config files in config/ directory. Each concern (server, DB, admin, middleware) has its own file. Self-hosted adds more complexity.
No magic. You get a VPS and configure everything yourself. cloud-init helps but you're writing server setup from scratch.
Static + dynamic config separation. Docker labels for routing are clever but verbose. Dashboard included but read-only by default.
Local dev needs Docker with Temporal server. Namespace, task queue, and worker config all in code. Temporal Cloud simplifies infra but not SDK config.
Heavy self-hosted setup. Postgres, Redis, worker processes. Many env vars for auth, storage, email. Managed version coming.
Docker setup is okay but realm config is massive. Admin console has 100+ settings.
Agent config is verbose. Tagging strategy, APM, and log parsing each require separate config. Dashboard setup is extensive.
Console generates metadata YAML automatically but the output is massive. Docker setup for local dev, Hasura Cloud for prod. Permission system is powerful but config-heavy.
Gen 2 is TS-based config but still multiple resource files. Each AWS service (auth, data, storage) needs its own config. Simpler than raw AWS but still AWS underneath.
Most complex setup. Rules DSL has its own learning curve. Index config is manual.
Self-hosted stack requires Prometheus + Loki + Grafana. Each has its own config. Provisioning as code helps but steep curve.
Dashboard complexity is enterprise-grade. Org setup, application config, groups, policies, and SAML/OIDC are all separate sections. SDK config minimal but prerequisite dashboard work is enormous.
Enterprise-grade secret management with enterprise-grade config. HCL policies, seal/unseal ceremony, auth backends. Overkill for 90% of teams.
The OG config nightmare. Loaders, plugins, resolve aliases, optimization splits. Every project ends up with 100+ line config. There's a reason Vite won.
Config hell. IAM alone takes a day. Each service needs its own config.