Samepage
From scattered inputs to structured updates
TL;DR
Product managers spend a disproportionate amount of time not building, but translating. They turn technical work into exec summaries, sprint output into stakeholder updates, and progress into shared understanding for audiences with different levels of context.
I led design for Samepage, a 0–1 AI product that removes that translation work. PMs bring messy inputs — notes, tickets, threads — and leave with structured, audience-ready updates in under a minute. I defined the product direction, designed the core AI interaction model, and shaped the go-to-market narrative. The product launch secured 20+ customers and growing.
Problem
Most AI writing tools solve the wrong problem for PMs. The issue isn't writing speed. It's translation. Turning a week of work into something a mixed audience can understand is a thinking problem, not a dictation problem.
Existing tools start with a blank prompt and expect PMs to know what to ask for. That's the hard part. In practice, PMs rewrite the same updates across Notion, Slack, and meetings — spending 3–4 hours a week on communication that should take minutes. Even then, teams stay misaligned because the format shifts and the signal gets lost.
Samepage's thesis: PMs communicate better when the system handles the structure, not just the words.
My role & approach
I didn't start with features. I started with a positioning question: what does this product need to be to actually solve the problem?
The answer shaped everything. Samepage had to be a clarity tool, not an AI writing assistant. That choice drove the interaction model, AI patterns, output format, and how we positioned it to customers.
I ran 17 discovery interviews with product leaders across B2B SaaS, then moved into rapid prototyping to test the core idea before investing in engineering.
What I designed
Connecting your work tools to AI
Before designing screens, I defined the core model:
- Inputs: Raw PM materials like notes, tickets, Slack threads, and Engineering issues
- AI layer: Structures, communication best practices, and dynamic content based on audience and context
- Outputs: Audience-ready updates for execs, engineers, or cross-functional teams
The key constraint: the AI handles structure, not just rewriting. Rewriting clean paragraphs isn't useful. Turning messy inputs into a clear, audience-appropriate narrative is the product.
AI-generated updates — the core experience
PMs had too much context and no fast way to distill it. At the same time, trust in AI was low. One wrong detail and the PM still owns it. Outputs had to feel ready to send, not something to clean up.
Show the source
Every section includes lightweight source references so PMs can see where content came from. This added some UI complexity, but removed the "is this accurate?" hesitation we saw in early testing.
Structure over freeform
Outputs follow a clear template — status, decisions, blockers, next steps. This improves accuracy and makes it easy to scan and verify. The output uses an editorial layout with clear hierarchy. In testing, cleaner layouts increased trust even when the content was the same.
Designing for AI uncertainty
Latency
AI isn't instant. Blank pages and generic spinners led to drop-off, so I replaced it with progressive reveal. Sections appear as they're generated, starting with title and status, then filling in detail. Users start reading right away, so it feels active, not blocked.
Bad outputs
Early results were often close, but off in subtle ways. A full regenerate wasn't helpful. I designed targeted edits instead. PMs can make simple text edits and the AI will update the rest.
Personalized prompts
As more updates were generated, the system became more tailored and began surfacing smarter prompts. This did two things: it reduced the time to create updates, and it improved structure and accuracy by learning from prior inputs.
The sidecar interaction model
AI tools that live in a separate tab or modal break the flow. PMs think in context while reviewing tickets, notes, or docs. The tool needed to live alongside the work, not pull them away from it.
I designed a sidecar — a persistent panel that sits next to the source material. PMs select content, open the sidecar, and see the generated update in place. No context switching. In testing, the sidecar consistently outperformed modal and standalone approaches on speed, trust, and repeat use.
The sidecar uses tighter type and spacing than the main canvas to signal it's a working space, not the final output. It can be pinned or dismissed and never takes over the screen.
Read receipts — making updates stick
As I dug deeper, another problem emerged. Even when updates were clear, there was no signal they were actually read. Updates were sent into Slack or email and disappeared into the stream. PMs had no idea who saw them, who missed them, or when to follow up.
Read receipts address this directly. Every update shows who has viewed it and when, turning communication from a one-way broadcast into something measurable. It creates a lightweight layer of accountability without adding friction.
This shifts the goal of Samepage updates — not just making them easy to create, but making sure they land. Teams can quickly spot gaps, follow up with the right people, and build confidence that stakeholders are actually informed.
Read status is surfaced inline with each update, showing viewer names and timestamps. Unread states are clearly indicated, making it easy to scan for gaps. The UI stays minimal and unobtrusive so it supports the update without distracting from the content itself.
Key decisions & tradeoffs
Clarity tool, not writing assistant
Positioned Samepage as a communication tool, not an AI writer. This shaped defaults, empty states, and what "done" looks like. Tradeoff: narrower audience, focused on PMs. Outcome: stronger fit and a clearer story.
AI-first, not AI-assisted
AI generates structure from raw inputs, instead of improving finished drafts. Tradeoff: more complexity around trust and error handling. Outcome: a differentiated experience that's hard to replicate with a simple AI add-on.
Structured outputs over freeform
Outputs follow a consistent format. Users can edit, but the AI always starts from a clear structure. Tradeoff: less flexibility for edge cases. Outcome: more accurate, scannable updates that build trust.
Editorial UX over tool-heavy UI
Designed the output like a document, not an app. Minimal chrome, content-first layout. Tradeoff: less visible "power" at first glance. Outcome: outputs feel ready to send, which created strong early buy-in.
Outcomes
Shipped
- 9 pilot customers across FinTech, MarTech, and Enterprise SaaS
- Prototype and positioning narrative used directly in sales conversations with 20+ customers
Impact
| Update time | Dropped from ~10–15 min to under 1 min across 58 PM sessions (90% reduction) |
| Repeat usage | 72% of users who created one update returned within a week (2x increase) |
| Alignment | 81% of pilot stakeholders felt more informed about product progress (10x improvement) |
Samepage has completely changed how I start my day. The signals I get every morning put me on the front foot instantly — 10x more effective than before. It's one of those rare products that actually gets better every single week.
What I Learned
Start with existing materials, not a blank canvas
A text box assumes users already know what to ask. That's the hard part. Start with their existing materials, not a blank canvas.
Presentation drives belief
The same output felt more trustworthy in an editorial layout than in a dense tool UI. Presentation drives belief.