Menu
Cloud database platform specialist covering Neon (serverless PostgreSQL), Supabase (PostgreSQL 16 with real-time), and Firebase Firestore (NoSQL with offline sync). Use when choosing or setting up cloud databases.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
Intent-First design craft specialist covering design direction, domain vocabulary, design memory, and post-build critique. Use when establishing design intent or auditing code against design principles.
Design tool integration specialist covering Figma MCP, Pencil renderer, and Pencil-to-code export. Use when fetching design context from Figma, rendering Pencil designs, or exporting to React/Tailwind code.
Documentation generation patterns for technical specs, API docs, user guides, and knowledge bases using real tools like Sphinx, MkDocs, TypeDoc, and Nextra. Use when creating docs from code, building doc sites, or automating documentation workflows.
Backend development specialist covering API design, database integration, microservices architecture, and modern backend patterns. Use when designing APIs, implementing server logic, authentication, or authorization.
Brand-aligned visual design system specialist for web projects. Enforces hero-first layout chaining, WCAG 2.1 AA accessibility, Lighthouse >= 80, and design token extraction from brand identity files. Covers color palettes, typography, spacing, and component specifications.
Brand-aligned copywriting specialist for marketing and product text. Enforces brand voice, anti-AI-slop rules, concrete numbers, and JSON section structure for downstream agent consumption. Covers hero, features, social_proof, cta, and footer sections with A/B variant output.
| name | moai-platform-database-cloud |
| description | Cloud database platform specialist covering Neon (serverless PostgreSQL), Supabase (PostgreSQL 16 with real-time), and Firebase Firestore (NoSQL with offline sync). Use when choosing or setting up cloud databases. |
| license | Apache-2.0 |
| compatibility | Designed for Claude Code |
| allowed-tools | Read, Write, Bash(psql:*), Bash(npm:*), Bash(npx:*), Bash(neonctl:*), Bash(firebase:*), Bash(supabase:*), Grep, Glob, mcp__context7__resolve-library-id, mcp__context7__get-library-docs |
| user-invocable | false |
| metadata | {"version":"2.0.0","category":"platform","status":"active","updated":"2026-02-09","modularized":"true","tags":"database, postgresql, nosql, serverless, real-time, offline, cloud","context7-libraries":"/neondatabase/neon, /supabase/supabase, /firebase/firebase-docs","related-skills":"moai-platform-auth, moai-lang-typescript, moai-domain-backend"} |
| progressive_disclosure | {"enabled":true,"level1_tokens":100,"level2_tokens":4500} |
| triggers | {"keywords":["neon","supabase","firestore","cloud database","serverless postgresql","real-time database","offline sync","pgvector","rls","database branching","vector database","nosql","mobile database"],"agents":["expert-backend","expert-devops","manager-spec"],"phases":["plan","run"],"languages":["typescript","javascript","python","go"]} |
Cloud Database Platform Coverage: Consolidated expertise for Neon (serverless PostgreSQL), Supabase (PostgreSQL 16 with real-time), and Firebase Firestore (NoSQL with offline sync).
Neon provides serverless PostgreSQL with auto-scaling, database branching, and scale-to-zero compute for cost optimization. Best for serverless applications, preview environments, and edge deployment with connection pooling.
Supabase provides PostgreSQL 16 with pgvector for AI/ML, Row-Level Security for multi-tenant apps, real-time subscriptions, and integrated auth/storage. Best for full-stack apps requiring real-time features and vector search.
Firestore provides NoSQL document database with real-time sync, offline caching, Security Rules, and mobile-optimized SDKs. Best for mobile-first apps, offline-first architecture, and cross-platform development.
Need serverless PostgreSQL with auto-scaling: Use Neon.
Need database branching for CI/CD: Use Neon branching.
Need edge-compatible database: Use Neon with connection pooling.
Need vector search for AI/ML: Use Supabase with pgvector.
Need Row-Level Security: Use Supabase RLS policies.
Need real-time subscriptions: Use Supabase real-time or Firestore listeners.
Need offline-first mobile app: Use Firestore with offline persistence.
Need SQL with real-time features: Use Supabase.
Need NoSQL flexibility: Use Firestore.
SQL vs NoSQL Decision: Choose SQL (Neon, Supabase) for structured data with complex relationships, ACID transactions, and query flexibility. Choose NoSQL (Firestore) for flexible schemas, offline-first mobile apps, and real-time sync across clients.
PostgreSQL Variants: Choose Neon for serverless auto-scaling and branching. Choose Supabase for integrated features (auth, storage, real-time) and pgvector.
Serverless Applications benefit from Neon's auto-scaling and scale-to-zero that reduce costs significantly.
Multi-tenant SaaS benefits from Supabase Row-Level Security providing automatic tenant isolation.
AI/ML Applications benefit from Supabase pgvector for vector embeddings and similarity search.
Real-time Collaboration benefits from Supabase Postgres Changes or Firestore real-time listeners.
Mobile-First Apps benefit from Firestore offline caching and mobile-optimized SDKs.
Preview Environments benefit from Neon database branching for per-PR databases.
Edge Deployment benefits from Neon connection pooling for edge runtime compatibility.
Cross-Platform Apps benefit from Firestore unified SDKs across iOS, Android, Web, and Flutter.
Serverless Compute: Neon (auto-scaling, scale-to-zero), Supabase (Supavisor pooling), Firestore (built-in serverless).
Database Branching: Neon (instant copy-on-write), Supabase (not available), Firestore (not available).
Vector Search: Neon (via pgvector extension), Supabase (native pgvector with HNSW), Firestore (not available).
Real-time Subscriptions: Neon (via logical replication), Supabase (native Postgres Changes), Firestore (native listeners).
Offline Support: Neon (not available), Supabase (limited), Firestore (first-class with IndexedDB).
Security Model: Neon (connection-level), Supabase (Row-Level Security), Firestore (Security Rules).
Mobile SDKs: Neon (community drivers), Supabase (TypeScript/JS native), Firestore (first-party mobile SDKs).
Neon Free Tier: 3GB storage, 100 compute hours/month, scale-to-zero idle free.
Supabase Free Tier: 500MB database, 1GB file storage, 2GB bandwidth/month, 50K MAU.
Firestore Free Tier: 1GB storage, 50K daily reads, 20K daily writes, real-time listeners included.
Neon Serverless Driver requires @neondatabase/serverless package with neon function for query execution. Use DATABASE_URL for direct connection and DATABASE_URL_POOLED for serverless/edge compatibility.
Supabase Client uses @supabase/supabase-js with createClient function. Environment variables SUPABASE_URL and SUPABASE_ANON_KEY for client-side, SUPABASE_SERVICE_ROLE_KEY for server-side.
Firestore Client uses firebase/app and firebase/firestore with initializeFirestore. Enable offline persistence with persistentLocalCache and persistentMultipleTabManager for multi-tab support.
Use Supabase CLI with supabase migration new and supabase db push for Supabase schema management.
Use neonctl or Neon API for database branching and reset operations in Neon.
Use Firebase CLI with firebase deploy --only firestore:rules for Firestore Security Rules deployment.
Neon supports Drizzle ORM with drizzle-orm/neon-http adapter, Prisma with @prisma/adapter-neon, and direct SQL with @neondatabase/serverless.
Supabase supports direct SQL with @supabase/supabase-js client, Drizzle ORM with Postgres driver, and Prisma with connection string.
Firestore SDK is the primary interface with no ORM abstraction layer needed.
For latest platform documentation, use the Context7 MCP tools:
Neon: Use mcp__context7__resolve-library-id with query "neondatabase/neon" to get the library ID, then mcp__context7__get-library-docs with topics like "branching", "connection pooling", or "auto-scaling".
Supabase: Use mcp__context7__resolve-library-id with query "supabase" to get the library ID, then mcp__context7__get-library-docs with topics like "postgresql pgvector", "row-level-security", or "realtime".
Firestore: Use mcp__context7__resolve-library-id with query "firebase" to get the library ID, then mcp__context7__get-library-docs with topics like "firestore security-rules", "firestore offline", or "firestore real-time".
For platform-specific implementation patterns, architecture details, and advanced features, consult the reference files:
Neon Serverless PostgreSQL at reference/neon.md covers database branching workflows, auto-scaling configuration, PITR and backups, serverless driver usage, Drizzle and Prisma ORM integration, and edge deployment patterns.
Supabase PostgreSQL 16 at reference/supabase.md covers pgvector for AI/ML, Row-Level Security policies, real-time subscriptions and presence, Edge Functions with Deno, Storage with CDN, auth integration, and TypeScript client patterns.
Firebase Firestore at reference/firestore.md covers NoSQL document modeling, real-time listeners with metadata, offline caching and sync, Security Rules with custom claims, transactions and batch operations, composite indexes, and mobile SDK patterns.
For comparative analysis and migration guidance, see reference/comparison.md which covers SQL vs NoSQL decision matrix, PostgreSQL variant comparison, migration strategies between platforms, feature parity mapping, and cost optimization strategies.
Status: Production Ready Generated with: MoAI-ADK Skill Factory v2.0 Last Updated: 2026-02-09 Version: 2.0.0 (Consolidated) Platforms: Neon, Supabase, Firestore
| Rationalization | Reality |
|---|---|
| "Serverless databases scale automatically, I do not need to think about limits" | Serverless billing scales automatically too. Unoptimized queries on auto-scaling databases create surprise bills. |
| "I will use the free tier for production, it has enough capacity" | Free tiers have connection limits, storage caps, and no SLA. Production workloads need production-tier guarantees. |
| "Real-time subscriptions are always better than polling" | Real-time subscriptions hold connections open. At scale, this exhausts connection pools. Poll when freshness tolerance allows. |
| "I will pick the database after building the application" | Database choice affects schema design, query patterns, and data modeling. Choosing late means refactoring early decisions. |
| "Connection pooling is handled by the platform" | Platform pooling has default limits. Serverless functions can exhaust connection pools rapidly without explicit configuration. |
