# Database Development Options for AI Agents **Updated:** 2026-09-17 **Purpose:** Choose a low-cost database or backend for test, personal, and early-stage projects without defaulting to Supabase. > **Agent rule:** Do not choose a provider from brand familiarity. First classify the project, then choose the smallest service that satisfies its data model, runtime, auth, storage, and deployment needs. ## Fast answer - **Choose Neon for a PostgreSQL project or a composable full backend.** Neon now offers GA Postgres, S3-compatible Object Storage, Managed Better Auth, Node.js Functions, scheduled and storage-event triggers, a PostgREST-compatible Data API, and an optional AI Gateway. Database, auth, storage, and functions share branch-aware deployment semantics. - **Choose Nhost when native Realtime and GraphQL matter more than Neon's branching model.** It includes Postgres, Auth, GraphQL, Realtime, Storage, Functions, and role-based authorization, with one active free project at a time. - **Choose Appwrite when you want a broad backend platform and can accept document-style databases.** Its free plan includes Auth, Databases, Storage, Functions, Realtime, and Sites, with two free projects that pause after one week of inactivity. - **Choose Turso for SQLite at the edge or a large number of tiny databases.** Its free plan includes 100 databases, 5 GB storage, 500 million row reads, and 10 million row writes per month. - **Choose Cloudflare D1 when the application already runs on Cloudflare Workers.** It is SQLite at the edge, not a drop-in Postgres replacement. - **Choose Convex for a TypeScript-first reactive application.** It is a backend platform, not a Postgres migration target. - **Choose Firebase when the application wants Google-managed Auth, Firestore, realtime features, and mobile tooling.** Its free Spark plan requires no payment method, but Firestore uses a document model and daily quotas. - **Choose MongoDB Atlas when the application naturally uses documents or MongoDB tooling.** The free cluster is 512 MB and should be treated as a learning and prototype tier. - **Choose Render Postgres for a small, disposable SQL database.** Its free Postgres instance is resource-constrained and intended for exploration and personal projects. - **Choose local SQLite when the agent needs a private scratch database.** No hosted service is required. Back up the file and do not treat it as production infrastructure. ## Decision tree for agents ### 1. Is the application already PostgreSQL-based? - **Yes:** Start with **Neon**. - **Yes, and it needs Auth, Storage, or Functions:** Start with **Neon**. Those backend primitives are now GA and can branch with the database. - **Yes, and it specifically needs a managed Realtime data layer or GraphQL:** Test **Nhost** first. Neon Functions can run WebSockets and SSE, but Neon has not shipped a separate managed realtime sync primitive yet. - **No:** Continue. ### 2. Does the application need a document database? - **Google ecosystem, mobile app, realtime document updates:** **Firebase Firestore**. - **MongoDB data model or MongoDB-compatible tooling:** **MongoDB Atlas**. - **TypeScript functions, reactive queries, and no SQL requirement:** **Convex**. - **General backend platform with Auth, Storage, Functions, and Realtime:** **Appwrite**. ### 3. Does the application need SQLite? - **Edge reads, many small databases, or embedded sync:** **Turso**. - **Cloudflare Workers runtime:** **Cloudflare D1**. - **Single-user, local, private, or disposable work:** **SQLite on disk**. ### 4. Is this only a cheap hosted test database? - **Small PostgreSQL test:** Render Postgres or Neon. - **Small SQLite test:** Turso or local SQLite. - **Short-lived container and database experiment:** Render or another platform with an explicit spend cap. - **Do not use Railway as a free-plan recommendation.** Its current offer is a one-time trial followed by a $1/month minimum, with usage-based billing beyond included credits. ## Ranked provider guide ### 1. Neon **Best for:** PostgreSQL projects, AI-generated applications, preview environments, and composable backends that need database, auth, file storage, API access, or server-side functions under one branch-aware control plane. **Current free plan:** $0, no time limit, no credit card required. Includes 100 projects, 100 CU-hours per project each month, 0.5 GB database storage per project, scale-to-zero after inactivity, ten branches, 5 GB Object Storage per project, Managed Better Auth for up to 60,000 monthly active users, and Functions with 10 active Capacity-Hours, 400 waiting Capacity-Hours, and 1 million invocations per project per month. **Backend status:** Lakebase Postgres, Object Storage, Functions, Managed Better Auth, Data API, and AI Gateway are GA. The AI Gateway is not part of the Free plan. It requires a paid Neon plan and prepaid credits. **Why agents should like it:** - PostgreSQL remains PostgreSQL. - Branches are useful for previews and isolated experiments. - Database state, auth state, object storage, functions, and configuration can follow the same branch instead of pointing every preview at production services. - Scale-to-zero reduces idle cost. - The API and CLI support programmatic project creation. - A typed `neon.ts` file can declare backend configuration, `neon config plan` can preview changes, and `neon deploy` can reconcile them. - The Data API is PostgREST-compatible, validates JWTs, and respects PostgreSQL Row-Level Security. - It is easier to export and move than a document-specific backend. **Trade-offs:** Neon is now a backend platform, but it is not a drop-in Supabase clone. It does not yet provide a separate managed realtime sync primitive. Functions currently run JavaScript or TypeScript on Node.js 24, and they are request-driven rather than a durable job queue. Managed Better Auth, Object Storage, Functions, and AI Gateway have region or account limitations. The AI Gateway requires a paid plan, and its prepaid balance can go slightly negative after a final metered request. Verify RLS, auth plugins, realtime behavior, function runtime, regions, and migration paths before moving an existing application. **Agent verdict:** Recommended default for new Postgres projects and now a credible first-choice backend platform when native managed realtime sync is not required. Official launch announcement: https://neon.com/blog/neon-backend-is-ga Official pricing: https://neon.com/pricing Backend principles and configuration: https://neon.com/docs/get-started/dev-experience Data API: https://neon.com/docs/data-api/overview Managed Better Auth: https://neon.com/docs/auth/overview Object Storage: https://neon.com/docs/storage/overview Functions: https://neon.com/docs/compute/functions/overview AI Gateway billing: https://neon.com/docs/ai-gateway/prepaid-credits ### 2. Nhost **Best for:** Projects that want a closer Supabase replacement rather than a database-only service. **Current free plan:** $0. One active project at a time. A free project pauses after one week of inactivity. Includes 1 GB database, 1 GB storage, 5 GB egress, Functions, Realtime APIs, infrastructure as code, automated deployments, unlimited users, and OAuth providers. **Why agents should like it:** - Postgres, Auth, Storage, Functions, Realtime, GraphQL, and role-based authorization are in one platform. - It reduces the number of replacement services required when leaving Supabase. - Data can be exported, which limits lock-in risk. **Trade-offs:** One active free project means it is poor for a fleet of simultaneously running test projects. The one-week pause matters for rarely used apps. Verify GraphQL, permissions, function behavior, and pause behavior before a production migration. **Agent verdict:** Recommended Supabase-like alternative when one active free project is enough. Official pricing: https://nhost.io/pricing ### 3. Appwrite **Best for:** A broad backend platform with Auth, Databases, Storage, Functions, Messaging, Realtime, and Sites. **Current free plan:** $0. Two projects. Free projects pause after one week of inactivity. Includes 5 GB bandwidth, 2 GB storage, 750,000 executions, 75,000 monthly active users, one database, one bucket, and two functions per project. **Why agents should like it:** - It covers more of the backend surface than a database-only service. - It has a clear project boundary for small personal applications. - It offers both cloud and self-hosted paths. **Trade-offs:** The default TablesDB model is not a drop-in Postgres replacement. Free database quotas include 500,000 reads and 250,000 writes per month. Free projects sleep after a week. Self-hosting shifts the infrastructure and backup work to the operator. **Agent verdict:** Strong platform alternative when the application is new or document-oriented. Official pricing: https://appwrite.io/pricing ### 4. Turso **Best for:** SQLite and libSQL applications, edge reads, local-first applications, and large numbers of small databases. **Current free plan:** $0, no credit card required. Includes 100 databases, 5 GB storage, 500 million monthly row reads, 10 million monthly row writes, 3 GB monthly syncs, and one day of point-in-time restore. **Why agents should like it:** - The free database count is unusually useful for agent-generated test projects. - SQLite keeps local development simple. - Idle databases cost storage rather than always-on compute. - It fits edge and local-first applications well. **Trade-offs:** It is SQLite/libSQL, not PostgreSQL. PostgreSQL extensions, JSONB behavior, RLS, triggers, functions, and transaction assumptions may require changes. Do not select Turso merely because the quota looks large. **Agent verdict:** Best free option for SQLite-shaped work, not for a low-impact Supabase migration. Official pricing: https://turso.tech/pricing ### 5. Cloudflare D1 **Best for:** Applications already running on Cloudflare Workers and needing SQL close to users. **Current free-plan position:** D1 is part of the Cloudflare Workers platform. The free tier is quota-based and includes a 500 MB per-database limit, with account-level database and read/write limits documented by Cloudflare. **Why agents should like it:** - Native Worker bindings make deployment straightforward inside Cloudflare. - SQLite is familiar and inexpensive for small structured datasets. - Read replication and time-travel restore support edge-oriented applications. - Prisma and Drizzle have documented integration paths. **Trade-offs:** D1 couples the application to Workers and SQLite semantics. It is not a drop-in replacement for Supabase Postgres. Moving an existing Vercel or Node application adds a runtime migration as well as a database migration. **Agent verdict:** Best when Cloudflare is already the runtime. Otherwise choose Neon or Turso first. Official product page: https://www.cloudflare.com/developer-platform/products/d1/ Official limits: https://developers.cloudflare.com/d1/platform/limits/ Official pricing: https://developers.cloudflare.com/d1/platform/pricing/ ### 6. Convex **Best for:** TypeScript-first applications that want reactive queries, server functions, and a managed backend without writing SQL. **Current free-plan position:** Convex provides a free tier with included database storage and built-in backend resources. Check the current limits before provisioning a large or always-on workload. **Why agents should like it:** - The schema and functions live close to the application code. - Reactive queries reduce glue code for collaborative interfaces. - It is a strong fit for new TypeScript applications and prototypes. **Trade-offs:** Convex is a backend model change, not a database swap. It does not preserve a PostgreSQL schema, SQL queries, RLS policies, or existing Supabase data-access code. Auth and platform limits must be checked against the application before adoption. **Agent verdict:** Good greenfield choice. Bad default for migrating an existing Supabase application. Official pricing: https://www.convex.dev/pricing Official limits: https://docs.convex.dev/production/state/limits ### 7. Firebase **Best for:** Mobile applications, Google Cloud integrations, document data, authentication, messaging, and realtime client experiences. **Current free plan:** The Spark plan is $0 and does not require a payment method. Firestore includes 1 GiB stored data, 10 GiB monthly network egress, 20,000 document writes per day, 50,000 reads per day, and 20,000 deletes per day. Authentication includes 50,000 monthly active users for supported services. **Why agents should like it:** - Strong SDK coverage across web and mobile. - Auth, messaging, analytics, hosting, and document storage are integrated. - Good fit when the product already belongs in Google Cloud. **Trade-offs:** Firestore is a document database with per-operation quotas. Query design matters. Moving from Supabase Postgres requires a data-model rewrite. Phone authentication has separate SMS billing considerations. **Agent verdict:** Strong mobile and document-backend option, not a SQL replacement. Official pricing: https://firebase.google.com/pricing ### 8. MongoDB Atlas **Best for:** Document data, MongoDB-compatible tools, and prototypes that need a managed document database. **Current free plan:** The free tier is $0 and provides a shared 512 MB cluster. The Flex plan is usage-based and can reach up to 5 GB, but it is not the same as a durable unlimited-free tier. **Why agents should like it:** - Mature drivers, SDKs, and examples. - Natural fit for document-shaped data. - Atlas supports search and vector features at higher service tiers. **Trade-offs:** 512 MB is a learning and prototype limit. MongoDB is not relational Postgres. Avoid it when the application needs joins, strict relational constraints, or SQL portability. **Agent verdict:** Useful document database, but not one of the best Supabase replacements for relational applications. Official pricing: https://www.mongodb.com/pricing ### 9. Render Postgres **Best for:** Small personal projects and disposable hosted PostgreSQL tests. **Current free plan:** Render lists a free PostgreSQL option with 256 MB RAM and 100 connections. Render describes free compute plans as suitable for exploring the platform, personal projects, and previews. **Why agents should like it:** - Familiar managed PostgreSQL. - Simple deployment model. - Useful when the application and database should live on the same platform. **Trade-offs:** The free instance is deliberately small. Confirm retention, expiration, backup, sleep, and storage behavior before relying on it. It is a weaker long-term default than Neon for branching and agent-created project fleets. **Agent verdict:** Good disposable PostgreSQL option. Use Neon when the project may become important. Official pricing: https://render.com/pricing Free-service limits: https://render.com/docs/free ## Providers that should not be called free ### Railway Railway is useful, but its current pricing is not a durable free tier. New users receive a 30-day trial with $5 in credits, then the Free plan is listed at $1 per month with limited resources. Usage beyond included credits is billed. Treat Railway as low-cost usage-based infrastructure, not as a free database provider. Official pricing: https://railway.com/pricing ### Prisma Postgres Prisma Postgres can be attractive when the application already uses Prisma. Do not add Prisma solely to obtain a free database. The ORM and migration layer are additional moving parts. Verify current pricing and limits directly before adding it to an agent-generated stack. Official product page: https://www.prisma.io/postgres ## Open-source projects worth considering The provider list above includes hosted services. This section covers open-source projects that can remove hosted-plan limits, provided the operator is willing to own deployment, upgrades, backups, monitoring, and security. ### PocketBase **Best for:** A small, self-hosted personal app that needs an API, authentication, file storage, realtime subscriptions, and an embedded SQLite database in one simple binary. **Why it belongs on the list:** PocketBase is MIT-licensed and unusually easy for an agent to run locally or on a small server. It is a strong answer when the real requirement is "a private backend for one small app," not a durable multi-region database. **Do not use when:** The application needs PostgreSQL compatibility, concurrent multi-writer scale, complex relational queries, managed backups, or a hosted free tier. PocketBase's SQLite foundation and single-binary operating model are the point, and also the boundary. **Agent verdict:** Add as the simplest self-hosted backend option. Treat it as a hobby and small-project choice, not the general Supabase replacement. Official site: https://pocketbase.io/ Repository: https://github.com/pocketbase/pocketbase ### Directus **Best for:** A self-hosted data platform that should expose an existing SQL database through REST, GraphQL, an admin interface, and agent-friendly API access. **Why it belongs on the list:** Directus sits above an existing database instead of forcing a new proprietary data model. It is a better fit than PocketBase when the project needs SQL portability, an operator-facing data interface, or a clean API over tables that already exist. **Do not use when:** The goal is the smallest possible deployment, the agent cannot operate a server, or a fully managed free tier is mandatory. Self-hosting means owning the Directus service, database, upgrades, backups, and public endpoint security. **Agent verdict:** Add as the strongest open-source API and admin layer for an existing SQL database. It is complementary to Neon or local PostgreSQL, not a database replacement by itself. Official site: https://directus.com/ Repository: https://github.com/directus/directus ### Already covered open-source platforms - **Nhost** is already included above and is the strongest open-source, PostgreSQL-preserving Supabase-style candidate. - **Appwrite** is already included above and offers both cloud and self-hosted paths, but its database model is not a drop-in PostgreSQL replacement. - **Supabase self-hosting** is possible, but it recreates a multi-service operating burden. Do not recommend it merely to avoid a small hosted bill. The local `agent-assist-registry` inventory and the private `fullrefit.co/repos` catalog were checked during this review. Neither produced a verified database-specific agent project that was stronger than the candidates above. The public catalog surface currently redirects to Airtable sign-in, so the catalog API was read directly for the available repository records. ## Cost and safety rules for AI agents 1. **Set the budget boundary before provisioning.** Prefer providers with hard quotas, scale-to-zero, project caps, or explicit spend limits. 2. **Do not infer free from a marketing page.** Record price, project limit, storage, compute, egress, read/write quotas, pause behavior, card requirement, and overage behavior. 3. **Separate database choice from backend choice.** Render primarily solves database hosting. Neon, Nhost, Appwrite, Firebase, Convex, and Supabase also solve parts of the application backend, but with different data models, runtime limits, and degrees of coupling. 4. **Preserve the data model.** PostgreSQL, SQLite, document stores, and reactive TypeScript backends are different choices. A free tier is not worth a rewrite unless the rewrite is intentional. 5. **Export before migration or deletion.** Save schema, data, storage objects, auth metadata, function source, environment-variable names, and restore notes. 6. **Use disposable credentials.** Give the agent the narrowest project-scoped key available. Never place a service-role key in browser code or a public prompt. 7. **Verify the live provider after provisioning.** Confirm the project exists, the database accepts a test query, the intended tables or collections exist, and the billing state is what you expected. 8. **Add a cleanup step.** The agent must record how to pause, delete, export, and recover the project before it creates one. 9. **Do not treat inactivity pauses as data loss protection.** A sleeping project is different from an archived backup. Keep an independent export. 10. **Prefer one provider per project until the need is proven.** A free fleet across six vendors creates more credentials, failure modes, and abandoned data than it saves. ## Agent provisioning checklist Before creation: - [ ] Project type classified as Postgres, SQLite, document, reactive backend, or local file. - [ ] Auth, storage, functions, realtime, and vector-search requirements listed. - [ ] Free limits and billing behavior checked from the provider’s official page. - [ ] Card requirement and overage behavior recorded. - [ ] Export and cleanup path identified. After creation: - [ ] Provider, project ID, region, plan, and creation date recorded. - [ ] Database connection verified with a harmless test query. - [ ] Schema or collections applied and verified. - [ ] Application smoke test completed. - [ ] Credentials stored in the approved secret manager. - [ ] Spend alerts or hard limits configured where available. - [ ] Backup or export completed. - [ ] Delete or pause instructions recorded. ## What recent developer discussion suggests The last 30 days of public discussion showed a consistent split: - Developers still want PostgreSQL for AI applications because it works with familiar tools and keeps the data model portable. - Users asking for cheap or free backends often want an API and backend services, not just a database. - Railway appeared in discussion as an underrated PostgreSQL option, but its official pricing makes it a low-cost usage-based service rather than a free-plan recommendation. - A high-engagement discussion criticized Supabase complexity around RLS, triggers, and functions. That is evidence to evaluate the whole backend surface, not evidence that every project should abandon Supabase. - The strongest agent-oriented options are the ones that expose a clear API, predictable limits, easy export, and programmatic project creation. Community evidence is directional. Official provider pricing controls the current limits above. ## September 17 Neon update This is a significant product-category change. Neon has moved from the guide's database-first option to a credible full-backend choice for many PostgreSQL applications. The important change is the combined GA surface: branch-aware Postgres, auth, object storage, functions, triggers, and HTTP data access can now be deployed and managed together. This does not make every Supabase-style alternative obsolete. Nhost remains the stronger default when the application specifically depends on a managed Realtime data layer, GraphQL, or its authorization model. Neon Functions can host WebSockets and SSE, but a function runtime is different from a managed realtime sync service. Neon's AI Gateway also sits outside the Free plan, and Functions are not a durable queue or workflow engine. For agents, the strongest improvement is environmental isolation. A preview branch can carry database state, auth state, files, function code, and configuration without silently writing to production services. That reduces one of the most common failures in agent-built applications. ## Current default For a new test or personal project, use this order: 1. **Neon** if the data model is PostgreSQL or the project needs a composable Postgres backend with auth, storage, functions, and branch-aware previews. 2. **Nhost** if the application needs native managed Realtime, GraphQL, or a closer Supabase-style bundle and one active free project is enough. 3. **Turso** if the data model is SQLite and the project benefits from edge or local-first behavior. 4. **Appwrite** if the project needs a broad backend platform and can use its database model. 5. **Cloudflare D1** if the application already runs on Workers. 6. **Convex** if the application is intentionally TypeScript-first and reactive. 7. **Firebase or MongoDB Atlas** when the application specifically fits their document ecosystems. 8. **Render Postgres** for a small disposable hosted database. 9. **Local SQLite** when hosting is unnecessary. Do not make Supabase the automatic answer. Do not make the cheapest quota the automatic answer either. Match the provider to the application, record the limits, and leave a recoverable path before the agent writes data. ## Research record General provider pricing and limits were checked on 2026-09-14. Neon's GA announcement, backend documentation, limits, and billing boundaries were checked on 2026-09-17: - Neon GA announcement: https://neon.com/blog/neon-backend-is-ga - Neon pricing: https://neon.com/pricing - Neon backend principles: https://neon.com/docs/get-started/dev-experience - Neon Data API: https://neon.com/docs/data-api/overview - Neon Managed Better Auth: https://neon.com/docs/auth/overview - Neon Object Storage: https://neon.com/docs/storage/overview - Neon Functions: https://neon.com/docs/compute/functions/overview - Neon Function triggers: https://neon.com/docs/cli/triggers - Neon AI Gateway billing: https://neon.com/docs/ai-gateway/prepaid-credits - Nhost: https://nhost.io/pricing - Appwrite: https://appwrite.io/pricing - Turso: https://turso.tech/pricing - Cloudflare D1: https://www.cloudflare.com/developer-platform/products/d1/ - Cloudflare D1 limits: https://developers.cloudflare.com/d1/platform/limits/ - Cloudflare D1 pricing: https://developers.cloudflare.com/d1/platform/pricing/ - Convex: https://www.convex.dev/pricing - Firebase: https://firebase.google.com/pricing - MongoDB Atlas: https://www.mongodb.com/pricing - Render: https://render.com/pricing - Railway: https://railway.com/pricing Recent public discussion was collected with `/last30days` for 2026-08-15 through 2026-09-14. The run searched web results plus Reddit, GitHub, Hacker News, LinkedIn, X, TikTok, Pinterest, and Digg. Reddit was partially rate-limited, and YouTube and Instagram produced no usable results in that run. The raw research file is `/private/tmp/last30days-db-providers/supabase-alternatives-with-generous-free-database-plans-for-ai-agents-raw.md`. The follow-up open-source pass checked the local `agent-assist-registry`, the repository catalog behind `https://fullrefit.co/repos`, and public GitHub sources. The catalog contained no verified database-specific agent project stronger than PocketBase or Directus for this guide. Relevant repository sources: https://github.com/pocketbase/pocketbase, https://github.com/directus/directus, https://github.com/nhost/nhost, and https://github.com/appwrite/appwrite.