Scout began with a reset: turn a shelved chatbot mandate into a discovery program for a trustworthy AI analyst inside Excel.

Turn a dead mandate into a discovery program

I was hired to ship a chatbot for hedge fund analysts. Two months in, GPT-4 changed the landscape enough that the original premise no longer made sense. We weren’t going to outspend the model labs at their own game, and another generic chat experience on top of financial data wasn’t going to create meaningful differentiation.

Instead of immediately pitching the next product idea, I proposed six weeks of discovery to understand where AI could genuinely make an analyst better at their job. The market was about to be flooded with AI demos; our differentiation needed to come from something harder to replicate: trust, proprietary data, and a deep understanding of the analyst’s actual workflow.

I took the discovery plan to my boss, ran the work with our PM, and presented the findings and product direction to Daloopa’s founders and executive team. That conversation became the green light for Scout.

Get close enough to the work to find the unlock

I ran discovery alongside our PM: 21 analyst interviews in New York and over Zoom, including sessions at funds where compliance rules meant no recordings and handwritten notes only. Static mocks weren’t getting us far. Analysts are an unusually literal and sophisticated audience, and it was difficult for them to react meaningfully to an AI workflow they couldn’t actually use.

Using Cursor and Claude Code, I built four working prototypes and put functioning software in front of customers within days. Two findings changed the direction: analysts would only trust an AI agent if its work was auditable and useful for what they needed to do next; and they weren’t going to leave their models to use it. Scout needed to live inside Excel.

I owned the synthesis, prototypes, and product strategy. I also mapped what we learned against the analyst’s 13-week earnings cycle so the roadmap followed the rhythm of their work rather than the capabilities of the technology. At zero-to-one, learning fidelity matters enormously.

Turn trust into architecture, not a feature

The biggest lesson from discovery was that Scout’s success would depend less on how intelligent it appeared and more on whether analysts could trust it to act inside a model they depended on. That led to five principles that became the architecture of the product: every number is a citation, grounded rather than generative, plan before act, reversible by design, and honest about gaps.

Every number is a citation

Any cell Scout writes can be traced back to its exact source, whether that’s a filing or a slide in a CFO’s presentation. Analysts need to audit the work, not simply trust the answer.

Grounded, not generative. Plan before act. Reversible by design. Honest about gaps

Scout works from Daloopa’s verified data layer with web search off. Before it changes a worksheet, the analyst can review and approve its plan. Snapshot and rewind make experimentation safe, while high-risk actions default to conservative behavior. When Scout lacks enough data or context, it says so and proposes a path forward.

I stayed close through two closed alphas and a public beta, but the goal was to move the quality bar out of my head and into the system itself. Scout became the front door to Daloopa’s broader ecosystem: the data layer, the add-in—which migrated into Scout at GA—and the API. We chose depth over breadth, and defined explicit entry and exit criteria for two closed alphas, public beta, and GA.

Step back in when the data gives you a reason to

Our PM departed in April 2026, and I stepped into the PM role through the end of the quarter. Beta instrumentation told us something important: customers who adopted Scout were using it heavily and repeatedly, but adoption wasn’t spreading on its own. We had a penetration ceiling, not a quality ceiling.

That changed the GA plan. Instead of expanding the feature set, I re-sequenced the roadmap around activation: self-serve onboarding, simplified plan mode, and removing as much entry friction as we could find. The roadmap followed what customers were doing, not what made for the most impressive demo.

The mistake I own

I let the beta aperture open too wide. Our heaviest users were generating as much as $500 a day in LLM costs while the company was still operating on its previous runway. I corrected it directly with deliberate usage limits and additional friction where we were subsidizing exploration, with a plan to remove constraints after the next financing round. Unit economics are a design constraint just like latency, usability, or technical feasibility.

Hand it off before you become the bottleneck

By this point, my boss had left and the founders had asked me to lead the product organization. The activation plan was set, and staying in the PM seat would have started working against the thing I was trying to build: a team that could own Scout without depending on me.

I handed execution to a newly hired PM, our senior product designer, and the engineering team. My role shifted from owning tasks to setting direction and holding the gates. Scout shipped to GA in September 2026 without me in the room. The bar held.

Our senior product designer grew into a true product partner during Scout, earned a promotion, and later rebuilt our entire design system working in Claude Code. That growth was theirs. My role was creating the conditions for it: a clear expectations document, weekly crit, and career conversations connected to meaningful ownership.