Case studies/ebba, Inc.
Product knowledge is the new engineering
ebba's product manager — no formal programming background — ships frontend for a $4B+ commercial real estate analytics platform, while a senior CTO owns the architecture. Veriloom is the layer that makes it safe.
Company
ebba, Inc.
Industry
Commercial real estate analytics
Platform
Veriloom
Founder time spent on code, alongside BD, sales, and customer relationships
Portfolio assets under management on platforms built with Veriloom
Production regressions across the platform's lifetime
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, and energy monitoring systems, transforms fragmented data into a unified analytics store, and distributes it to end-users through dashboards and natural-language queries.
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 puts the person closest to customers directly into the product experience, while senior engineering leadership ensures architectural integrity. The PM simultaneously runs business development, sales, marketing, and customer relationships — with frontend development taking roughly 10% of their working time.
The results: 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.”
Cofounder & Product Manager
ebba, Inc.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 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: 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.
ebba's frontend isn't a single app. It's two systems that must work in concert — the kind of architecture that typically requires experienced engineers to manage safely.
System A
A vendor platform where ebba has full source access and complete design flexibility. Used to build and render the data visualisations and reports for property portfolios.
System B
A branding and experience layer on top of the dashboards. Each client gets a personalised, white-labelled interface that integrates with their operations.
For most AI-assisted development, the answer is still no. Agents produce code that looks correct but misses edge cases, violates patterns, or introduces subtle regressions. Veriloom changes the equation by making engineering discipline automatic and non-optional.
Every feature begins as an architectural conversation. “Add dark mode” becomes: implement dark mode such that the toggle updates both the vendor dashboard and the React overlay without a full-page refresh, persists in localStorage, follows the component theming system, and handles client-specific branding overrides. The plan is precise enough for any agent to execute without ambiguity.
Features decompose into tickets with explicit success criteria and defined edge cases. When an agent picks up a ticket, there is zero ambiguity about what “done” means. Vague prompts produce vague code — the ticketing discipline eliminates that failure mode at the source.
Every change passes through gates before it can reach production. Integration and E2E tests execute real user workflows against staging — login, navigate, toggle, verify rendering across both frontend layers. CSS regressions, accessibility breaks, responsive failures, and cross-platform sync bugs are caught before merge.
The CTO reviews architectural decisions, defines component patterns, and maintains the technical standards Veriloom enforces. Senior engineering judgment sets the rules; Veriloom applies them automatically on every change. That's what allows a non-technical PM to contribute production code safely and confidently.
Comprehensive dark-mode implementation synchronised across the vendor dashboard system and the React branding layer — component theming, user-preference persistence, client-specific overrides. Each integration point tested in isolation before merging.
A systematic update to the design language across both frontend layers, ensuring visual consistency for white-labelled client deployments. Each client's branded experience updated and verified individually.
A steady stream of UX improvements driven by direct customer feedback. Because the person writing the code is also the one handling customer relationships, there's zero translation loss between what users need and what gets built. Features ship in days, not sprint cycles.
Throughout all of this, 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 the point.
The most compelling proof that this works isn't maintenance and incremental improvement. It's net-new product development that wouldn't exist under a traditional model.
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. With the Veriloom workflow proven, ebba committed to building it in-house within two quarters.
The conventional model — large engineering teams, long development cycles, expensive outsourcing for custom work — assumes that code quality requires headcount. ebba demonstrates the opposite. 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. 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 is 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.
Veriloom turns AI coding agents into a discipline you can ship with. Get in touch to talk through your stack and team shape.