# How to Vibe Code Your Own Fibery (and Stop Paying for It)

> Operating system for orgs run by nerds

- Site: https://fibery.io
- Category: No-Code Work Management & Productivity
- Verdict: **Serious undertaking** (18/100 vibecodeable)
- Estimated effort: 4-6 months of serious development

## Verdict

Build a heavily scoped single-user relational task manager with markdown docs instead, or keep paying for the real platform.

Fibery combines a dynamic schema engine, multiple view renderers (Gantt, Timeline, Whiteboard), a custom BI charting module, collaborative text editing, and an MCP server into one cohesive product. Vibecoding a personal clone of the core relational database and simple views is feasible in a few weekends, but replicating the complete platform depth—especially the custom BI reporting engine, multi-directional cross-space relations query builder, and resilient MCP server integrations—is a monumental architectural undertaking for a solo developer.

### What you can't replicate

- Seamless multi-directional relational graph querying across dozens of custom user-defined schemas
- Production-grade custom BI charting engine with complex historical aggregation capabilities
- Bulletproof two-way sync connectors with enterprise tools like Jira and GitHub

## What it does

A connected, customizable no-code work management platform that merges relational databases, views, whiteboards, documents, and built-in BI into a single modular workspace.

### Core features

- Dynamic Relational Metadata Schema (Arbitrary databases, fields, and multi-directional relations)
- Multiple View Engines (Table, Board, Timeline, Gantt, Calendar, Whiteboard, Dashboard)
- Collaborative Real-Time Rich Text Documents and Comments
- Custom BI Reporting Engine (Aggregations, charts, and operational metrics over relational data)
- Natural Language AI Features and Remote Model Context Protocol (MCP) Server
- Bi-directional Third-Party Integrations (GitHub, Jira, Slack, Zapier)

## The business

### Pricing

- Free: $0 — for small teams up to 10 users
- Standard: $12/mo — billed annually per user
- Pro: $20/mo — billed annually per user
- Enterprise: $40/mo — billed annually per user

### Funding

$8.3M raised.
- Seed Round
- Series A
Investors: Accel, Y Combinator

Founded 2017.
Team size: ~30.

## The hard parts

- Building a performant dynamic metadata engine in SQL/Postgres that allows arbitrary custom user-defined entity types and cross-space relations without schema migrations
- Implementing real-time multi-user collaborative editors and whiteboard synchronization (CRDTs/Operational Transformation)
- Developing a custom charting/BI query compiler that translates user-configured dashboards and filters into optimized SQL aggregations on the fly
- Exposing a robust Model Context Protocol (MCP) server that maps natural language tool intents from external LLMs securely into database mutations with access controls

## How to vibe code Fibery

### Prerequisites

- Node.js (free): Required runtime for Next.js full-stack development and backend scripts.
- GitHub (free): Version control and repository hosting.

### Recommended AI tools

- Claude Code: Best-in-class agentic coding tool for scaffolding complex full-stack architectures and handling multi-file database abstraction layers.
- Cursor: Ideal editor for fine-tuning complex React frontend view components like custom Kanban boards and tables.

### Stack

- Frontend: Next.js (App Router) with Tailwind CSS and shadcn/ui
- Backend: Next.js Server Actions and API Routes
- Database: Neon (Serverless Postgres) with Drizzle ORM
- Auth: better-auth
- Payments: None (Personal clone)
- Other: Liveblocks (for collaborative document editing), Anthropic API (for AI assistant and MCP integration)

### Hosting

- Vercel (Hosting the Next.js frontend and serverless API endpoints.): $0-20/mo
- Neon (Serverless Postgres database supporting relational schemas.): $0/mo

### Build guide

1. **Project Initialization & Database Schema Foundation** — Initialize a Next.js project with TypeScript, Tailwind CSS, and Drizzle ORM connected to Neon Postgres. Define meta-schema tables to store custom database definitions, field configurations, and relational links dynamically.

```
Initialize a Next.js 16 project using the App Router, Tailwind CSS, and TypeScript. Configure Drizzle ORM to connect to a Neon Postgres database using environment variables. Create a flexible meta-schema database model using JSONB and relational tables to represent user-defined databases (e.g., Databases table, Fields table with field types, Entities table storing jsonb record data, and Relations table mapping entity links). Include proper foreign key indexes, TypeScript interfaces for the dynamic schema engine, and a robust migration setup. Ensure the code is production-grade, cleanly modularized, and fully typed.
```

2. **Authentication & Workspace User Management** — Implement authentication using better-auth to secure the personal workspace and manage user sessions.

```
Integrate `better-auth` into the Next.js application using Neon Postgres as the data store. Set up email/password authentication and Google OAuth login providers. Create clean sign-in and sign-up pages using Tailwind CSS and shadcn/ui. Implement protected routes middleware ensuring only authenticated users can access workspace settings and database views. Write robust error handling for auth edge cases and verify session persistence across server actions and client components.
```

3. **Dynamic Entity CRUD & Table View Engine** — Build the core data management interface allowing users to create records, configure custom fields, and display them in a dynamic table view.

```
Build a dynamic table view interface in Next.js that renders records based on user-defined database schemas. Implement server actions for creating, updating, and deleting entity records stored as flexible JSONB payloads alongside typed columns. Build inline cell editing, sorting, filtering by field values, and pagination. Use shadcn/ui components and Lucide icons to replicate a clean, responsive spreadsheet-like workspace UI inspired by Fibery.
```

4. **Board, Calendar, and View Switcher** — Add alternative view visualizations including a Kanban Board view categorized by workflow states and a Calendar view.

```
Implement a view switching mechanism supporting Table, Kanban Board, and Calendar views for any custom database. For the Kanban Board, build drag-and-drop card movement (using @dnd-kit or similar) that updates entity status fields via server actions. For the Calendar view, display entities mapped to date fields across month and week grids. Ensure all views share the same underlying dynamic entity store and filter/sort states.
```

5. **Collaborative Documents & Rich Text Integration** — Integrate collaborative rich text document editing into entities using Liveblocks or TipTap.

```
Add collaborative rich text document editing to entity detail views using TipTap and Liveblocks for real-time cursor presence and co-editing. Allow users to embed database views and mention other entities directly within the document body. Build a clean split-pane layout where the left side shows entity properties and relations, and the right side hosts the collaborative document editor.
```

6. **AI Assistant & Custom Model Context Protocol (MCP) Endpoint** — Implement an internal AI chat assistant and a basic remote Model Context Protocol (MCP) endpoint to query workspace data via natural language.

```
Create a secure API route acting as a Model Context Protocol (MCP) server endpoint that exposes workspace databases, entities, and relations to external AI assistants like Claude. Implement tool definitions for querying entity records, creating new items, and searching text fields. Also build an embedded sidebar chat interface leveraging the Anthropic API (Claude Sonnet) that uses these workspace tools to answer natural language questions about project data.
```

### Cost vs paying

**Starting costs (one-time):**

- Custom domain (optional): $12/yr
- AI coding tool subscription: $20
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Vercel Hobby / Neon Free: $0/mo
- Anthropic API usage for AI & MCP features: ~$5-15/mo
- Total: ~$10/mo

- Paying for the SaaS instead: $12 - $40 / user / mo
- Build time: 80-120 hours
- AI tool credits: $20 (Claude Pro or Cursor)
- Break-even: 1 month

## Sources

- [Fibery Official Website & Features](https://fibery.io)
- [Fibery Pricing & Plans](https://fibery.io/pricing)
- [Fibery MCP Server Documentation](https://fibery.io/features/mcp-server)