Rowy is an open-source low-code platform designed for developers and teams building applications on Firebase and Google Cloud Platform. It provides a spreadsheet-style interface to manage Firestore collections with familiar CRUD operations, while enabling the creation of cloud functions triggered by data changes—all within a browser-based environment. This eliminates the need to switch between database consoles and code editors, streamlining backend development for internal tools, CMS systems, or SaaS products. Rowy keeps all data and functions hosted exclusively on your GCP project, ensuring full control over your infrastructure without third-party data access.
It targets developers who want to accelerate backend development without sacrificing flexibility. Whether you’re building a content management system, an internal dashboard, or a data-driven app, Rowy allows you to define schemas, set up automations with NPM modules, and enforce permissions—all without writing infrastructure code. Its integration with Firestore and support for custom fields make it a powerful Airtable alternative tailored for the Firebase ecosystem.
What You Get
- Spreadsheet UI for Firestore - Manage your Firebase Firestore data with a familiar spreadsheet interface that supports CRUD operations, bulk CSV/JSON/TSV imports and exports, column customization (freeze, hide, resize), sorting, filtering, and multiple views per collection.
- Cloud Functions with JS/TS - Build automated workflows triggered by data changes using JavaScript or TypeScript, with full access to NPM packages and external APIs like SendGrid, Twilio, Algolia, or BigQuery without leaving the browser.
- 30+ Rich Field Types - Use advanced field types including JSON, Markdown, Rich Text (HTML), Code editors, Image/File uploads, Date pickers, Single/Multi-select dropdowns, Aggregate fields (derived from sub-tables), Connector fields (cross-collection references), and Action fields to trigger cloud functions via clickable buttons.
- Granular Role-Based Access Control - Define table-level and field-level permissions for team members with customizable roles, ensuring secure data access across different user groups without manual IAM configuration.
- Built-in User Management - Manage internal users and permissions directly in Rowy without relying on Firebase Authentication UI, enabling seamless collaboration for non-technical team members.
- HTTP Connectors - Fetch and display live data from any external HTTP endpoint directly in your tables, enabling real-time integrations with third-party services without writing backend code.
Common Use Cases
- Building a CMS for Firebase - Use Rowy to create an admin interface for managing blog posts, products, or user profiles in Firestore with rich text editing, image uploads, and custom field validation—all without building a React admin panel from scratch.
- Creating internal tools with no-code automation - A marketing team uses Rowy to manage campaign data in Firestore and triggers automated email campaigns via SendGrid when a new lead is added, using pre-built code blocks or custom JS functions.
- Problem: Managing Firestore data manually → Solution with Rowy - Developers waste hours navigating the Firebase console to update records, test queries, or trigger functions. Rowy provides a spreadsheet interface with bulk edits and one-click cloud function triggers to reduce backend overhead by 70%.
- Team workflow for product teams - Product managers define data schemas and views in Rowy, while engineers write cloud functions for business logic. Non-technical team members update data directly in the spreadsheet, with permissions ensuring they only see relevant fields.
Under The Hood
Rowy is an open-source platform that empowers developers to manage Firestore data and cloud functions through a spreadsheet-like interface, combining low-code simplicity with powerful backend capabilities. It is built as a modern React application with TypeScript, emphasizing component modularity and Firebase integration.
Architecture
The architecture follows a monolithic yet modular structure, clearly separating concerns between UI, state management, and backend services.
- The codebase adopts a layered pattern with distinct modules for UI, Firebase integration, and project logic, ensuring clean separation of concerns
- Component interactions are handled through React Router, Jotai for state management, and Material-UI for consistent UI rendering
- Design patterns such as Provider for global state, lazy loading for performance, and component composition are consistently applied
- Clear boundaries exist between authentication, table management, settings, and UI elements, promoting maintainability
Tech Stack
The project is built using modern web technologies with a strong emphasis on developer experience and performance.
- Built with TypeScript and React, leveraging Vite for fast builds and development, and React Router for navigation
- Relies heavily on Firebase for backend services, MUI for UI components, and Jotai for state management
- Uses Craco and SWC for advanced configuration, alongside Vitest and Happy DOM for testing and ESLint/Prettier for code quality
- Integrates Monaco Editor to provide in-browser code editing capabilities with Firebase and Firestore schema support
Code Quality
The project demonstrates a mature development approach with strong adherence to modern React and TypeScript practices.
- A comprehensive testing ecosystem is in place, including extensive test files that cover various scenarios and edge cases
- Error handling is consistently implemented with structured try/catch patterns and meaningful error propagation strategies
- Code follows naming conventions, type safety, and architectural standards to ensure readability and maintainability
- While the codebase is well-organized with minimal technical debt, some areas could benefit from more granular documentation
What Makes It Unique
Rowy stands out through its innovative integration of spreadsheet-like UX with powerful backend services and developer tools.
- Implements React Suspense and lazy loading with dynamic chunk naming to optimize client-side routing and performance
- Extends Firebase SDK types through custom TypeScript interfaces for enhanced type safety and developer experience
- Offers in-browser code editing capabilities that directly integrate with Firebase services and Firestore schema definitions
- Employs Jotai atom scopes for isolated state management, enabling flexible context handling while maintaining global consistency