At a Glance
| Metric | Value |
|---|---|
| Founder time on code | 10% |
| Portfolio assets under management | $4B+ |
| Production regressions | 0 |
Executive Summary
ebba, Inc. is a commercial real estate analytics platform serving property management companies, with a combined portfolio asset value of $4 billion. The platform integrates with major property management, ERP, planned preventive maintenance, energy monitoring systems and more, transforms fragmented data into a unified data store optimised for analytics, and distributes the data to end-users via dashboards and NLP.
One of ebba's cofounders — a product manager with no formal programming background — ships production frontend code using AI coding agents orchestrated through Veriloom. A senior CTO architects the system and oversees all technical decisions, while the PM handles day-to-day frontend development within that architectural framework.
This model allows the person closest to customers to directly shape the product experience, while senior engineering leadership ensures architectural integrity and production reliability. The PM simultaneously manages business development, sales, marketing, and customer relationships — with frontend development taking roughly 10% of their working time.
The results speak for themselves: a complex, multi-platform enterprise frontend maintained at high quality with zero production regressions, continuous UX improvements shipping directly from customer feedback, and a new custom application revenue stream that wouldn't exist under a traditional development model.
“For me, it's critical that the product looks great and feels great for the end user. With Veriloom enforcing engineering discipline on every change, I can focus on what matters — building the right features for our customers — while spending only a fraction of my time on code.”
The Thesis: Product Knowledge as a Development Superpower
The conventional wisdom in enterprise software is clear: complex systems require large, dedicated engineering teams. A platform integrating with multiple property management and ERP systems, rendering real-time dashboards for institutional clients, and handling sensitive financial data should demand a substantial frontend engineering effort.
ebba, Inc. challenges that assumption. By combining deep product knowledge with Veriloom's enforced engineering discipline, the company demonstrates that the right workflow guardrails can dramatically expand who is able to contribute production-quality code — and how efficiently.
The key insight is that the PM's non-technical background is not a limitation to be overcome — it's an advantage to be leveraged. They understand the customer's mental model better than any engineer working from specs. They know which features matter, which edge cases users actually encounter, and which design decisions impact retention. Veriloom bridges the gap between that product intuition and production-quality code.
The Platform Architecture
ebba's frontend consists of two interrelated systems that must work in concert:
A dashboard design tool — a vendor platform where ebba has full source code access and complete design flexibility, used to build and render data visualisations and reports for property portfolios.
A custom React application — a branding and experience layer that sits on top of the dashboards, providing each client with a personalised, white-labelled interface that integrates seamlessly with their operations.
These systems interact in non-trivial ways. Theming must stay synchronised across both layers. Scripts propagate between platforms. A change to the React overlay can affect dashboard rendering, and vice versa. This is genuinely complex frontend architecture — the kind that typically requires experienced engineers to manage safely.
The CTO designs the overall system architecture, defines component patterns, and reviews all significant changes. The PM handles day-to-day frontend development within that architectural framework, using Veriloom to ensure every change follows established patterns and passes quality gates before reaching production.
How Veriloom Makes This Possible
The critical question is not “can AI agents generate code?” — they clearly can. The question is: “can that code be trusted in production?” For most AI-assisted development, the answer is still no. Agents produce code that looks correct but misses edge cases, violates architectural patterns, or introduces subtle regressions. The review burden often erases the productivity gain.
Veriloom changes this equation by making engineering discipline automatic and non-optional.
Structured Planning
Every feature starts with a detailed planning session — not a casual prompt, but a structured architectural conversation. “Add dark mode” becomes: “Implement dark mode such that the toggle updates both the vendor dashboard system and the React overlay without a full-page refresh, preserves user preference in localStorage, follows our component theming system, and handles edge cases in client-specific branding overrides.”
The planning output must be precise enough for any agent to execute without ambiguity. This forces clarity before a single line of code is written.
Granular Ticketing
Features are decomposed into independently testable work units, each with explicit success criteria and defined edge cases. When an AI agent picks up a ticket, there is zero ambiguity about what “done” means. Vague prompts produce vague code — Veriloom’s ticketing discipline eliminates this failure mode.
Quality Gates and Testing
Every change passes through automated quality gates before it can reach production. Integration and end-to-end tests execute real user workflows against staging environments — login, navigate to a report, toggle a feature, verify rendering across both the dashboard layer and the React overlay. This catches CSS regressions, accessibility breaks, responsive design failures, and the subtle interaction bugs that emerge when two frontend platforms must stay synchronised.
CTO Oversight and Architectural Governance
The CTO reviews architectural decisions, defines component patterns, and maintains the technical standards that Veriloom enforces. This combination — senior engineering judgment setting the rules, Veriloom enforcing them automatically on every change — is what allows a non-technical PM to contribute production code safely and confidently.
What Has Been Shipped
Dark Mode and Cross-Platform Theming
A comprehensive dark mode implementation requiring synchronisation across both the vendor dashboard system and the React branding layer — including component theming, user preference persistence, and client-specific overrides. The Veriloom workflow ensured each integration point was tested in isolation before merging.
Full UI Rebrand
A systematic update to the design language across both frontend layers, ensuring visual consistency for white-labelled client deployments. Each client's branded experience was updated and verified individually.
Continuous UX Improvements
A steady stream of user experience improvements driven by direct customer feedback. Because the person writing the code is also the person handling customer relationships, there is zero translation loss between what users need and what gets built. Features ship in days, not sprint cycles.
Production Stability
Throughout all of this development, the platform has remained stable for hundreds of active users managing portfolios worth billions. No critical regressions from new deployments. The quality enforcement layer catches issues before they reach production — which is exactly the point.
New Revenue: The CapEx Forecasting Application
The most compelling proof that this model works isn't just maintenance and incremental improvement — it's net-new product development.
A major client approached ebba with an idea for a CapEx forecasting application: a purpose-built tool for commercial real estate budgeting, integrated directly with ebba's data platform. Under a traditional development model, building this kind of application would require significant outsourcing or additional hiring — a substantial investment for a targeted vertical tool.
With the Veriloom workflow proven in production, ebba committed to building it in-house within two quarters, fully integrated with the existing platform and delivering all features the client specified.
The client's response: immediate commitment to pay upfront for development, plus an annual license for the finished product.
This isn't a one-off. It's a repeatable model. ebba can now build custom applications for high-value clients without outsourcing, without the traditional cost and timeline constraints. Each build generates development revenue plus recurring license fees.
The Bigger Picture
ebba's story illustrates a structural shift in how enterprise software can be built and maintained. The conventional model — large engineering teams, long development cycles, expensive outsourcing for custom work — assumes that code quality requires headcount. Veriloom demonstrates that quality is a function of discipline, not team size.
When the right workflow guardrails are in place, the person with the deepest product knowledge can ship production code — not because they've become a software engineer, but because the system enforces engineering standards automatically. The CTO sets the architectural vision. Veriloom enforces it on every commit. And the PM translates customer needs directly into working software, without the friction of handoffs, misinterpretation, and review cycles.
For enterprise teams evaluating AI-assisted development, ebba offers a concrete proof point: a production platform serving institutional clients, running on complex multi-system architecture, with frontend code shipped by a non-technical founder — at quality standards indistinguishable from traditional engineering output.
About Veriloom
Veriloom is the engineering discipline layer for AI-driven software development. It wraps AI coding agents — currently supporting Claude Code and Codex, with additional agents on the roadmap — with deterministic execution controls, policy-enforced quality gates, live guardrails, and an immutable audit ledger.
| Component | Function |
|---|---|
| Core | Execution runtime |
| Gate | Policy enforcement |
| Sentinel | Live guardrails |
| Ledger | Immutable audit trail |
| Relay | Local-first cache + sync |
| Command | Hosted control plane |
veriloom.ai — Engineering discipline for AI-driven development