Can I vibecode Caspio?

Build a comprehensive, production-ready substitute for Caspio's core features in an empty repository.
Use Next.js 15 (App Router), TypeScript, Tailwind CSS, PostgreSQL, Drizzle ORM, and Docker Compose. Do not offer alternative stacks or require external hosted services.

The core objective is to build a low-code database platform that allows users to create custom business applications, multi-user portals, and interactive dashboards without writing code, acting as a visual app builder on top of a relational database.

Core Architecture & Database Functionality:
- Implement a dynamic database schema builder where users can create apps, tables, and define fields.
- Support robust field types: text, rich text, number, currency, date/time, boolean, dropdown (select), file/image attachments, calculated formulas, and foreign-key relations.
- Ensure the backend dynamically translates these configurations into secure database schemas and queries using Drizzle ORM.
- Provide built-in CSV import/export capabilities to easily migrate or back up table data.

Visual App Builder & User Interfaces (DataPages):
- Build a point-and-click interface to generate various 'DataPages': web forms (submission and update), searchable grids, tabular reports, galleries, kanban boards, and interactive charts/dashboards.
- Ensure all views are strictly derived from the single canonical schema, reflecting real-time data.
- Include a snippet-based deployment mechanism where generated forms and reports output an embed code (like an iframe or JavaScript snippet) so they can be integrated into external CMS platforms or websites seamlessly.
- Implement advanced filtering, sorting, and pagination for all report views.

Security, Users, & Access Control:
Build a closest honest personal substitute for Caspio in an empty repository.
Use Next.js 15, TypeScript, PostgreSQL, Drizzle ORM, and Docker Compose to wire it all together; do not offer alternative stacks or languages.

The core loop is: model structured records in one database-backed business app, provide grid, form, kanban, and filtered report views, and expose a documented API. Do not aim to be a general platform; focus on deep, reliable implementation of this specific core loop.

Ensure the first run works locally with a single documented command (e.g., `docker compose up --build`).

Store all user data locally by default, avoiding any external SaaS dependencies for core functionality, and make data export straightforward via a dedicated API endpoint or script in standard formats like CSV or JSON.

Put all secrets, API keys, and database credentials in a `.env` file, ship a `.env.example`, and implement pre-commit hooks or CI checks to ensure credentials are never accidentally committed to version control.

Create workspaces, bases, tables, fields, records, attachments, relations, and saved views. Support text, number, currency, date, boolean, select, formula-lite, and relation field types. Build grid, form, kanban, and record-detail views from one canonical schema.

Store every record and schema modification in the PostgreSQL database for auditability and durability, including audit history and trash restore functionality.

Design all side effects to be idempotent and resilient. Add role-based permissions and optimistic concurrency checks.

Build in rate limiting, dead-letter queues for unprocessable tasks, and a mechanism for secret rotation. Provide CSV import/export and a token-authenticated REST API generated from the schema.

Ship a complete Docker Compose setup with health checks for all services, migrations, seed data, database backup scripts, schema export format, and clear documentation.

Design a minimal but polished web UI with clear states for empty, loading, success, and recoverable errors, ensuring accessible keyboard navigation, focus states, and sensible contrast.

Implement strict input validation using modern libraries (like Zod), enforce safe data handling, safe filenames, and gracefully handle unavailable APIs without crashing the application.

Write focused unit tests for the core logic, schema management, and at least one robust end-to-end happy path test using an automated testing framework.

Create an exhaustive README detailing the setup process, system architecture, permission models, data storage locations, backup/restore steps, and limitations.

Strictly avoid adding multi-tenant user accounts, billing systems, telemetry, tracking analytics, or any hosted control plane. Do not claim to reproduce proprietary data, network liquidity, regulated access, or frontier infrastructure.

Deliberately leave out full spreadsheet formula compatibility, hundreds of automations and integrations, and large-enterprise governance and vendor-managed scale.

Finish by running the test suite, building the application, and outputting the exact commands used to verify the system. Fix errors rather than merely describing them.