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
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
How does this work? 🤔
Essentially, it's schema to UI generation.
You define which fields are required, their types, and where they are located. Dogen then rebuilds itself to match your needs automatically.
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 and their validations.
Misleading security claims - 'runs locally' doesn't guarantee security or data protection. Service account keys can even be exfiltrated from local machines.
Overprivileged access - violates security best practices by giving unnecessary access to cloud 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 actual 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 therefore can use the Client SDK and security rules.
Runs sensitive operations through auditable, open-source code in your own Firebase project.
Lowest privilege principle - follows security best practices by only giving the necessary access.
Complete transparency - all operations visible in Network tab of your browser, and in Firebase logs. Actions are attributed to the users.
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.
Flat Pricing
Client based 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. Pay per client project (90 rebuilds included) as you scale your data management needs.
Included per client:
- Everything in Base
- 20 Entity Blueprints
- 200 Fields
- 90 Client Rebuilds per month
- 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
- Admin role
- Private Support
Advanced multi-role capabilities are on the roadmap. If you have a specific use case, please reach out.
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