NoSQL Database Clients for Humans
Create intelligent, type-safe admin UIs for your existing Firestore databases. Production-ready in minutes, without any codebases to maintain.
DB Client x Admin Panel x GUI Client
Database clients validate on behalf of database engines, not your business. Have you noticed it?
Inconsistent Types
Some dates are stored as Strings, others as Timestamps. Some relationships are stored as Strings, and others are References.
Field Name Typos
In some documents, you have typos like "lenght" instead of "length", or "calender" instead of "calendar".
Impossible Values
A person's birthdate shouldn't be in the future, and their height shouldn't be 37 feet.
Format Issues
You store phone numbers as Strings, but sometimes with +1, sometimes with dashes, sometimes with parentheses.
Invalid References
Your document relationships and file references point to non-existent paths, breaking data integrity and causing errors.
Forgotten Fields
Your documents are sometimes missing required fields, because you simply forgot to add them.
Admin Panels help, but they're built to manage flat, simple data, not entire databases.
The Hidden Cost
On average, companies lose
of revenue due to poor data quality
Source: MIT Sloan Management Review
The Productivity Tax
Customizing internal tools could cost
of your developer productivity
Even if you're willing to invest in customization, features come first, and data management comes.. eventually.
With priorities shifting, eventually often turns into never.
The Dogen Way
Domain-Aware Database Clients
Database clients provide power and flexibility, but lack guidance. Admin panels provide safety and guidance, but lack power and flexibility. Dogen combines the best of both worlds.
Power + Flexibility + Safety + Guidance
Adding a New User
Standard Approach:
- Manual field creation for every document
- Type each field name, type, and value
- No guidance on required fields
- Prone to typos and inconsistencies
Dogen Approach:
- Pre-defined interface with all fields ready
- Red indicators show required empty fields
- Field names and types already configured
- Intuitive guidance from the start
Managing User Data
Standard Approach:
- All fields displayed as plain text strings
- No visual differentiation between types
Dogen Approach:
- Specialized UI for each field type
- Image paths display as actual images from Firebase storage
Data Validation
Standard Approach:
- Accepts invalid email formats
- Stores incorrect file types without warning
- No real-time validation feedback
- Data integrity issues accumulate silently
Dogen Approach:
- Real-time validation with red indicators
- Clear error messages for each field
- Visual feedback for invalid file paths
- Prevents bad data from entering system
Deeply Nested Data Management
Standard Approach:
- All data crammed into one overwhelming view
- Manual text input for enum fields (error-prone)
- Difficult to navigate complex nested structures
- Fields are out of order
- No guidance on array element types
Dogen Approach:
- Intuitive folder-like navigation for nested data
- Intuitive UIs and validations, at any depth
- Enum fields show as dropdowns with valid options
- Drag and reorder array items effortlessly
- Undo/restore capabilities for accidental changes
Multiple View Modes
Standard Approach:
- No alternative viewing modes
- No copy/paste functionality
- No visual diff capabilities
Dogen Approach:
- Alternative JSON Tree mode for lower level control and flexibility
- Monaco editor (VS Code) for raw JSON text editing
- Visual diff highlighting (green/red changes)
- Easily copy and paste between documents
Querrying, Browsing, and Navigating
Standard Approach:
- Basic filtering by field
- Single view for results
- No multi-select capabilities
- No pagination
- Individual delete only
- No error indicators
Dogen Approach:
- Smart field suggestions for filtering
- Switch between List and Table views
- Batch select multiple items
- Adjustable items per page
- Bulk copy as JSON or delete
- Visual error indicators for schema violations (red highlighting)
Both support: Real-time streaming, subcollection navigation, collection/document creation/deletion, and querying
Define Your Entities in Seconds
Start by defining your business entities with their fields and types. Here's the blueprint for the User example shown above.
From this blueprint, Dogen codegen produces type-safe UI components, runtime validation logic, and a complete CRUD interface. Custom validation rules and business logic can be layered on top as needed.
It's All About TypeSpec
TypeSpec allows you to rapidly build UIs by selecting from rich data types. You can choose from core types like Bool, DateTime, Double, Int, List<T>, Map<K extends String, V>, and String, as well as custom entities you define. These core types can also be enhanced with @ flavors like DateTime(@FutureEvent) to provide specialized validation rules, behavior, and UI components.
See a few more TypeSpec examples. Hover over any example for more details.
← Swipe to see more examples →
Mix and match types to create exactly the data structure your domain needs. Entity names like Address and OrderStatus are examples of custom entities you could define.
Move fast, break nothing.
It's still the same underlying data. Dogen just gives you a better interface to it. Think of it as a semantic layer—bridging the gap between raw database documents and how you actually think about your domain.
Privacy, Security & Auditability at its Core
Dogen is architected from the ground up with security and privacy as fundamental principles.
Open Source Extension
Dogen Service
Dogen Web Client
Firebase Extension
Performs admin operations on behalf of the client.
Dogen Service
Generates and deploys static Flutter Web clients (JS) from blueprints.
Flutter Web Client
Communicates only with your Firebase project's resources.
Open Source Extension
Sensitive operations are performed using the Firebase Admin SDK through the Dogen Firebase Extension. It's code is open source, reviewed, and approved by Firebase's team.
Security Rules Enforcement
The client is registered as a Firebase application, and uses Firebase's Client SDK, respecting your security rules just like all your other Firebase applications.
100% Data Privacy
Your actual data never leaves your Firebase project. Dogen only receives schema definitions—the blueprint, not actual data.
100% Auditability
Monitor all operations in real-time through your browser's Network tab and Firebase's function logs. Every request made is auditable.
Built Different: Security Over Convenience
Most GUI clients prioritize quick setup over security. Dogen takes a different approach.
🚨 Other GUI Clients (1-minute setup)
Use Admin SDK exclusively for all operations which bypasses security rules along with their validations.
Often claim to be secure due to running on your machine. However, running locally doesn't automatically guarantee security or data protection.
Violates security best practices by giving overprivileged access to resources.
Black box operations - you can't see what they're doing with your credentials. Additionally, cloud logs will show the service account as actor, not the individual user.
No real-time streaming support (Admin SDK limitation) means slower UIs and more reads incurred.
🛡️ Dogen (5-minute setup)
Integrates natively with Firebase as a proper application, and uses the Client SDK and security rules.
Performs sensitive operations through auditable, open-source code running in the Dogen Firebase Extension inside your Firebase project.
Follows the least privilege principle by only giving the lowest necessary access to resources.
Complete transparency - all operations visible in Network tab of your browser, and in Firebase logs. Actions are attributed to the individual user.
Real-time streaming support (Client SDK perk) means faster UI updates and fewer reads incurred.
Complete Feature Set
Everything you need for professional application management
The Dogen Advantage
Why teams choose Dogen for their application management needs
Ship Way Faster
Focus on building features, not data management tools.
Own Your Data
Your resources, your data, your rules. Complete control.
Better Data Structures
Create ideal data structures every time, no compromises.
Enforce Data Integrity
Type safety, schemas, and custom validations keep your data reliable.
Firebase Native
Perfect harmony with Firebase products.
5-Minute Setup
Install via Firebase extension and start immediately.
Pricing
Straightforward pricing. No hidden fees, no surprises.
Premium clients allow you to define custom entities and can be rebuilt as needed.
🎯 Base
Full-featured database client with all operations. Import/export data, manage files, run jobs—everything except custom entities and rebuilds.
This includes:
- 1 Base Client
- Unlimited databases & projects
- Job managment + CSV/JSON
- File management & storage
- Restaurant demo entities
- Admin role
- Community support
💻 Developer
Perfect for developers and small projects. Define type safe entity schemas, and validations.
Included per client:
- Everything in Base
- 20 Entity Blueprints
- 200 Fields
- 30 Client Rebuilds per month
- Rate limited after 30 rebuilds
- Admin role
- Community support
🏢 Business
For teams with more sophisticated modeling needs. Offers expanded capacity and responsive support.
Included per client:
- Everything in Base
- 40 Entity Blueprints
- 400 Fields
- 90 Client Rebuilds per month
- Rate limited after 90 rebuilds
- Admin role
- Private Support
Why would I ever use multiple clients? 🤔
Dogen allows you to manage all your Firebase projects with one client. However, when you have multiple domains, separate clients makes things easier.
Think: A restaurant reviews app versus a car rental platform. Both might have a User entity, but a reviews app user has favoriteRestaurants while a rental app user has drivingRecord.
You could get around this through various techniques, but you're probably better off with different clients.
The Backstory
Born from real pain points building production systems
Before Dogen, my team and I built a PCI-DSS certified payment gateway and credit card vault that handled millions of secure transactions. A key part of the system was a JSON based configuration layer responsible for things like banks, currencies, and country-specific rules. It worked brilliantly.
But managing it was a different story. Building a dedicated management tool kept getting pushed aside for more urgent tasks. As a result, every update required us to manually edit raw JSON in the production database. It was risky, stressful, and a poor use of engineering time.
That experience stuck with me. While JSON and schemaless NoSQL databases are ideal for creating rich, complex data models, the tools to effectively manage this complexity haven't kept up. I built Dogen to close that gap, offering structure, validation, and a dependable way to interact with your data.
Ready to Get Started?
Join developers who've simplified their data management