A demo engine
for outbound.
An open-source observability platform selling against Datadog and Splunk bills. Instead of a “we're cheaper” email, every prospect got a hosted page showing their own bill, their own savings, and an AI that answers questions from the real docs.
A “we're cheaper” email is noise. A page showing their bill is an argument.
Two phases. Phase 1 with CRO Shani Shoham built the demo engine, the personalized pages, the cost model, and the Ask AI that grounds them. Phase 2 under Jacob Swiss found the accounts worth showing them to and drove the outreach. Every prospect landed on a page built for them, not a generic pitch.
One input becomes a page.
A company and its current vendor become a hosted, personalized cost-comparison page at its own URL. Nothing hand-edited, the whole site regenerates from one CSV.
The savings figure isn't a number pulled from air. Each account is profiled from a dozen signals, then priced against the incumbent's live rate card. Where the saving comes out near-zero, the page flips to a value pitch instead of a price one. It never pretends a saving exists when it doesn't.
The signals pulled per account before a dollar figure is shown:
A page a prospect actually landed on:
An AI that only speaks from the docs.
Every demo page carries an in-page Ask AI. It runs on a retrieval index built over OpenObserve's entire public knowledge surface, so a prospect can interrogate the product and get answers grounded in current documentation, not a model's guess.
The same index does double duty. It answers questions on the demo page, and it grounds the outbound email copy, so a claim in a cold email traces back to a real passage in the docs. One knowledge base, one source of truth, powering both the pitch and the product Q&A.
Try it, this is the live index:
A redesigned console the demo could live in.
To make the demos read as product, not marketing, I rebuilt the OpenObserve console UI, its real colors, dashboards, and terminology, as a standalone interactive mockup with an AI-first assistant baked in.
Point the right page at the right person.
Stop guessing who to email. Find accounts showing real observability-migration signals, draft one verifiable hook each, and send, every lead pointed at its own matching demo page.
Sourcing was a headless browser, not a data vendor: a Playwright session logs into LinkedIn once, then walks job-posting URLs. A hiring post name-dropping Datadog or OpenTelemetry is a company actively wrestling with observability spend. The whole campaign then runs from Google Sheets and Apps Script, no separate server, threading follow-ups into the original Gmail conversation.
The engineering underneath
Sourcing: one manual LinkedIn login saves a reusable session; a scraper walks job URLs with human-like delays (4–7s after load, 6–12s between jobs) and resume support, writing clean title / company / JD rows. Titles are keyword-scored, observability terms weighted heaviest.
Personalization: step one pulls exactly one concrete, verifiable hook from the profile, or returns NONE. Step two pairs that hook with a vendor-specific pain library and the matching demo page, in one of three styles: hypothesis, curiosity, or minimal.
Threaded send: Apps Script builds a raw RFC-2822 MIME message with explicit In-Reply-To / References headers and sends via the Gmail API, so follow-ups land inside the original thread. Status and timestamps write back to the Master Sheet.
The pages did the talking.
The targeting and hooks landed: strong opens, and strong click-through to the personalized demo pages, every session watchable in PostHog replays shared with the team. The follow-up sequence then iterated the positioning, from a pure cost-savings pitch toward the broader observability pain the pages could speak to.
What the engagement taught.
Personalization depth beats volume
A generic "we're cheaper" email is noise to an engineer. A page with their stack, their pod count, and their actual bill is an argument. The demo page did the "why switch" pitch the cold email couldn't.
One verifiable hook, or none
The load-bearing rule of the personalization pipeline. If the model can't pull a real, specific signal from a profile, it falls back to a vendor-pain draft. It never invents a plausible-but-fake hook. Fake reads worse than generic once a prospect notices.
Ground every claim in real docs
Both the on-page answers and the email copy pull from the same RAG index over OpenObserve's own docs and GitHub. A number or a feature claim traces back to a real passage, so the pitch never drifts into something the product can't back up.
Vendor pricing pages move
Elastic's shift to Serverless / VCU billing broke a flat $/GB comparison mid-engagement (caught in the March review). The cost model needs a re-verification cadence, not static assumptions.
A page about them beats an email about us.
← Back to the systems