You specify an experience without designing it by defining the user's goal, the entry point, the sequence of steps, the states the system can be in, and the conditions that count as "done" — never a layout. This shifts your job from drawing screens to defining behavior, so a designer inherits intent instead of decoration.
Quick Answer: Write requirements as goal → entry point → steps → edge cases → done-when, and let states (empty, loading, error, success) stand in for screens. Skip colors, spacing, and component choices entirely — those are the designer's job, not yours.
Most PMs who try to "give design direction" default to sketching a screen in their head and describing it in words: "there should be a button at the top right that says Save." That's a layout instruction wearing a requirements costume. It tells a designer where you'd put something, not what the experience needs to accomplish — and it quietly claims a decision that isn't yours to make.
The fix isn't to write less detail. It's to write more detail about the right things: what the user is trying to do, what can go wrong, and what "working" looks like — and less detail about pixels, positioning, and visual hierarchy. That reallocation is the entire skill this article teaches.
Why PMs default to designing instead of specifying
PMs default to designing because a screen feels more finished and defensible than a written behavior spec, and because most PM training emphasizes deliverables (mockups, wireframes) over the underlying logic those artifacts represent. The result is specs that look precise but actually under-specify the behavior that matters.
A rough box-and-arrow sketch feels like progress. It's tangible, shareable in Slack, and easy to nod along to in a review. A paragraph about "what happens when the network drops mid-save" feels like homework — abstract, harder to visualize, easy to skip. But the sketch answers a question no one asked ("where do things go?") while dodging the one that actually determines quality ("what happens when things go wrong?").
This isn't a new problem — it's the same failure mode cognitive load research warns about, just applied upstream. When a PM over-specifies visual layout, they're often unconsciously trying to reduce their own uncertainty about the outcome, not the user's. For a broader grounding in why this distinction matters across the discipline, see this complete guide to product design and UX for PMs.
The tell: nouns vs. verbs in your own spec
Read your last requirements doc and highlight every noun that names a UI element (button, modal, card, dropdown) versus every verb that names a user action (save, confirm, retry, dismiss). If nouns dominate, you've drafted a layout brief. Verbs are the unit of a real UX requirement — they describe behavior, which is portable across any visual solution a designer proposes.
| Signal you're designing | Signal you're specifying |
|---|---|
| "Add a modal with a Cancel and Confirm button" | "The user must be able to abandon this action without losing prior work" |
| "Put a spinner in the top bar" | "The system must indicate that a save is in progress" |
| "Red text under the field" | "The user must understand which field failed and why" |
| "Three-dot menu with Edit/Delete/Duplicate" | "The user needs a way to modify or remove a saved item" |
The mental shift: from screens to behavior and success
Making this shift means replacing "what does it look like" with three questions asked in order: what is the user trying to accomplish, what could interrupt that, and how would anyone — user or system — know it succeeded. Answer those and a designer has everything needed to propose a layout.
This isn't about withholding opinions on design — it's about sequencing them correctly. You can absolutely have a point of view on a flow's shape. You just express it as intent ("the user should never lose a draft") rather than as instruction ("put an autosave indicator next to the title in gray text"). Design literacy — understanding why a layout choice works, not just naming it — is what makes this distinction real instead of semantic. See design literacy fundamentals for PMs for the underlying vocabulary.
Goals over screens
Every flow exists to serve a user goal — a specific outcome the user came to accomplish, stated as a job, not a feature. "Let the user save incomplete work without losing it" is a goal. "Add a Save Draft button" is a UI element that might satisfy it, or might not.
Borrow directly from Jobs to Be Done here: instead of specifying the interface, specify the job the user hired the product to do in this moment. JTBD, as codified by Clayton Christensen and popularized operationally by Tony Ulwick and Bob Moesta, insists the job is stable even when the solution changes — which is exactly the property you want a requirement to have. Read the complete guide to Jobs to Be Done if this framing is new to your team.
Flows over layouts
A flow is the ordered sequence of steps a user takes toward the goal, independent of what each step looks like. Write it as a numbered list of actions and system responses, not a sequence of screens. "User enters title, then clicks Save, then sees confirmation" describes a flow; a wireframe of three connected boxes describes one possible rendering of it.
Flows should also account for where the user is coming from and where they go next — which is really a customer journey lens applied at flow granularity. If your flow spec doesn't reference the moment before entry and the moment after exit, it's a fragment, not a flow. The complete guide to customer journey mapping is useful for zooming out to that level when a flow spec keeps needing "but what happens before/after this."
States over screens
A state is a condition the system can be in that changes what the user sees or can do — not a specific screen design. The canonical set almost every flow needs:
- Empty — nothing exists yet; what does the user see before they've created anything?
- Loading — an action is in progress; how does the user know to wait?
- Populated — the normal, successful case with data present.
- Error — something failed; what does the user learn, and what can they do next?
- Partial/degraded — some but not all data loaded, or a non-fatal issue occurred.
Naming these five states for any flow you specify does more to prevent a broken shipped experience than any amount of visual detail — because most production bugs and support tickets come from an unhandled state, not an ugly button.
Specifying content and constraints instead of copy and pixels
Specify content by describing what information must be present and why, not the exact words or their placement — and specify constraints as hard limits and business rules the design must respect, regardless of how it's laid out. Both are precision tools that don't touch pixels.
For content: instead of writing the actual microcopy ("Oops! Something went wrong"), specify the information requirement ("the error message must name which field is invalid and what value is expected"). This gives a designer or writer room to find the right tone while guaranteeing the user never gets a generic, unhelpful error. Constraints work the same way — "must support titles up to 200 characters" is a constraint; "the title field should be 400px wide" is a layout decision disguised as one.
A short taxonomy of constraints worth stating explicitly
- Data constraints — required fields, character limits, valid formats, uniqueness rules.
- Timing constraints — how fast must feedback appear (a widely cited human-computer-interaction benchmark, Jakob Nielsen's response-time thresholds, puts perceived instantaneity at roughly 0.1 seconds and the point users' attention drifts at around 1 second — useful directional targets, not universal deadlines).
- Permission constraints — who can perform this action, and what happens if they can't.
- Platform constraints — offline behavior, low-bandwidth behavior, device capability differences.
- Business-rule constraints — anything that must be true regardless of how the screen looks, such as "a draft can't be marked complete without a title."
Naming these explicitly prevents the single most common design-review argument: a PM rejecting a mockup for violating a rule they never actually wrote down. If the rule wasn't in the spec, that's a specification failure, not a design failure — a distinction worth internalizing before you critique a first draft. For how to give that kind of feedback without re-designing the screen yourself, see this guide to critiquing design as a PM without overstepping.
The specification template: goal, entry, steps, edge cases, done-when
The template below has five parts, each answering one question a designer would otherwise have to guess at: why does this exist, where does it start, what happens in order, what could go wrong, and how do we know it worked. Filling all five for every flow is the discipline; the format itself is deliberately simple.
| Field | Question it answers | What to avoid writing here |
|---|---|---|
| Goal | Why does the user want this? | A feature name |
| Entry point | Where/how does the user arrive here? | A screen name |
| Steps | What has to happen, in order? | Button labels or positions |
| Edge cases | What could interrupt or complicate this? | "Handle errors gracefully" (too vague) |
| Done-when | How do we know it succeeded? | A visual description of success |
Worked example: a save-draft flow
Goal: Let a user preserve in-progress work so they can leave and resume later without losing anything they've entered.
Entry point: The user is mid-way through creating or editing an item (a document, a form, a post) and either explicitly chooses to save incomplete work, or navigates away/loses connectivity before finishing.
Steps:
- User has entered at least one piece of content in an otherwise-incomplete item.
- User triggers a save, either explicitly (an action) or implicitly (an automatic interval, or an attempted exit).
- System persists the current state of all entered fields, including ones that would fail full validation.
- System confirms the save occurred, in a way distinguishable from a full/final submission.
- User can later return to this exact item and resume from where they left off, with all prior content intact.
Edge cases:
- User has entered nothing — there's nothing meaningful to save; define whether this is a no-op or blocked.
- Network fails mid-save — the user must find out the save didn't complete, not silently lose work.
- User has multiple drafts of the same type — must be able to distinguish them (by name, timestamp, or content preview).
- User edits the same draft on two devices — define whether the older or newer save wins, or whether conflict is even a case you handle in v1.
- Draft exists but the item type has since changed (a template updated, a required field added) — define whether the draft opens with a warning, migrates, or breaks.
Done-when: A user can close the item mid-entry, return at any later time — including after a network failure during the save attempt — and see every piece of content they had entered, with no ambiguity about whether the current version is saved.
Notice what's absent: no mention of a "Save Draft" button, no mention of where a draft indicator appears, no color or copy. A designer reading this template has enough to propose several legitimately different layouts — autosave with no button at all, an explicit save action, a persistent draft-status indicator — and all of them would satisfy the spec.
How Prodinja supports this without doing the design for you
Prodinja pairs a Wireframing lo-fi composer with Spec Studio so a PM can rough out a structural sketch — boxes, not polish — right alongside the written intent from a template like the one above. The sketch communicates layout intuition; the spec carries the actual requirement. Neither one is asked to do the other's job, and a designer receiving both gets direction, not a decoration to reverse-engineer.
This matters because the failure mode this article is arguing against — a PM handing over a finished-looking mockup that quietly encodes untested assumptions — is exactly what happens when the sketch is the only artifact. Pairing a rough structural sketch with a living written spec (one that can carry revisions the way a PR carries diffs) keeps the layout conversation and the requirements conversation legible as two separate things, which is the whole point of specifying without designing.
Key Takeaways
- Specify goals, not screens — describe what the user is trying to accomplish, not where a button sits.
- Write flows as ordered actions, not a sequence of mockups; the flow should survive any visual redesign.
- Name states explicitly — empty, loading, populated, error, and partial/degraded cover most flows and prevent the bugs that visual polish can't catch.
- Specify content requirements, not copy, and constraints, not layout dimensions — both preserve precision without dictating pixels.
- Use the five-part template — goal, entry point, steps, edge cases, done-when — for any flow you hand to a designer.
- The nouns-vs-verbs test is a fast self-check: if your draft spec is full of UI element names, you've drafted a layout, not a requirement.
- Pairing a rough structural sketch with a written spec (as Prodinja's Wireframing and Spec Studio are designed to let you do) keeps intent and layout separate without losing either.
Frequently Asked Questions
How do I write UX requirements if I don't know how to design?
You write UX requirements by specifying the user's goal, the flow of steps, the states the system can be in, and what counts as success — none of which require design skill. This is precisely the skill set a PM already has: understanding user goals and business constraints, not visual craft.
What's the difference between a UX requirement and a design spec?
A UX requirement defines behavior and intent — what must happen and why; a design spec defines the visual and interactive solution — layout, components, and styling that satisfy that behavior. A good UX requirement should be satisfiable by multiple different design specs.
Should PMs write user stories or a full experience spec?
Use a full experience spec (goal, entry point, steps, edge cases, done-when) for any flow complex enough to have multiple states or edge cases; a simple user story is fine for small, single-state changes. The template in this article scales down easily — skip sections that are trivially answered, but don't skip asking the question.
How detailed should edge cases be in a UX spec?
Edge cases should be detailed enough that a designer or engineer never has to invent behavior on the spot for a scenario you could have anticipated — typically covering empty/zero states, failure/interruption, conflicting or duplicate data, and permission boundaries. Vague instructions like "handle errors gracefully" don't count; name the specific error and the specific expected response.
Can specifying experience without designing slow down a project?
It typically speeds delivery up rather than slowing it down, because a designer working from a clear behavioral spec makes fewer wrong guesses and needs fewer rounds of rework than one interpreting an under-specified mockup. The upfront time spent on goals, flows, and edge cases is repaid in review cycles saved later.