The three audiences framework: Writing for everyone at once
How to serve new users, returning users, and power users without cluttering your interface
You’re writing a tooltip for a ‘Save’ button.
User A sees it for the first time. They don’t know what ‘save’ means in this context—save to the cloud? Save locally? Save a draft?
User B sees it for the hundredth time. They know exactly what it does. The tooltip is just noise.
User C has been using your product for years. They’ve memorized every keyboard shortcut. They find tooltips insulting.
Same tooltip. Three completely different experiences.
Most UX writers handle this by choosing one audience and annoying the other two. We optimize for new users (verbose, explanatory) and annoy power users. Or we optimize for experts (terse, efficient) and confuse beginners.
But here’s what I learned building products: you don’t get to choose your audience. They’re all using your product right now. At the same time.
The three audiences framework is a system for writing copy that serves new users, returning users, and power users simultaneously—without cluttering your interface or compromising clarity.
Understanding the three audiences
Every product has three distinct user states, each with different needs:
Audience 1: New users (The explorers)
Who they are:
First time using this feature or product
Don’t know what’s possible
Don’t know your terminology
High anxiety, low confidence
Need to understand why before how
What they need:
Context: What is this? Why does it matter?
Safety: Can I break this? Is this reversible?
Consequence: What happens next if I click this?
Expectations: What should I expect to see?
Guidance: What should I do first?
What frustrates them:
Jargon without explanation
Assumed knowledge
Too many options without guidance
Actions with unclear consequences
Fear of breaking something or triggering something irreversible
Audience 2: Returning users (The practitioners)
Who they are:
Used this before, but not regularly
Understand the basics
Don’t remember all the details
Medium confidence
Know what they want to do, might forget how
What they need:
Quick reminders: What does this do again?
Efficiency: Just tell me the key info
Clarity: Which option is which?
Gentle guidance: Where do I find X?
What frustrates them:
Being treated like complete beginners
Lengthy explanations of things they already know
Having to read paragraphs to find one piece of info
Tutorials they can’t skip
Inconsistent labels (they’ve memorized the old ones)
Audience 3: Power users (The masters)
Who they are:
Use this daily or weekly
Know all the features
High confidence, high expectations
Want speed and shortcuts
Often customize everything
What they need:
Speed: Keyboard shortcuts, quick actions
Efficiency: Get out of their way
Power: Advanced options
Respect: Don’t insult their intelligence
What frustrates them:
Time tax: Unnecessary modals or extra clicks (every unnecessary click costs them 2 seconds, which becomes hours over a year)
Tooltips explaining obvious things
Confirmation dialogs they can’t disable
Wizard-style flows that prevent direct access
“Helpful” hints they’ve seen 100 times
Anything that slows them down or adds friction
The challenge: Writing for competing needs
How do you write one piece of UI copy that serves the explorer, the practitioner, and the master?
The short answer: You don’t write one piece. You write in layers.
The solution: Progressive disclosure and layered copy
The core principle: Present information in progressive layers using progressive disclosure—a well-established design principle where you reveal complexity gradually based on user need. New users see everything. Power users see only what they need.
Think of it as concentric circles: Layer 1 (the primary goal/label) sits at the center, Layer 2 (helpful context) forms the next ring, and Layer 3 (full documentation) creates the outermost layer.
Layer 1: The primary goal (the label)
What this does in the fewest words possible
Visible to all users, always
Must be clear even without context
Layer 2: The helpful context (the tooltip/description)
Brief explanation or example
Visible on hover, tap, or expand
Skippable by those who know
Layer 3: The full documentation (the help/guide)
Complete explanation, edge cases, alternatives
Linked, not inline
Only accessed when needed
Example 1: A “make public” button
Layer 1: The primary goal (the button) “Make public”
Layer 2: Helpful context (the hover text) “Anyone with the link can view”
Layer 3: Full documentation (the link/help) “Learn about sharing settings →”
Why this works:
Power users: See “Make public,” understand instantly, click immediately (3 seconds)
Returning users: Hover, confirm their understanding, click (5 seconds)
New users: Read tooltip, still unsure, click help link to learn more (30+ seconds, but they get what they need)
All three audiences served. Zero extra UI clutter.
Example 2: A “batch edit” feature
Layer 1: The primary goal (the menu item) “Edit multiple items”
Layer 2: Helpful context (the submenu description) “Select items to edit fields at once”
Layer 3: Full documentation (the first-time overlay) [Overlay on first use]: “Select the items you want to edit, then change any field. Your changes will apply to everything selected. You can undo this anytime.”
Why this works:
Power users: They’ve done this before, they just click and go
Returning users: Quick reminder of how it works
New users: Full explanation with reassurance, but only once
Example 3: Error prevention
Layer 1: The primary goal (the requirement) “Password must be 8+ characters”
Layer 2: Helpful context (the progressive feedback) As they type, show: “6/8 characters” with a progress indicator
Layer 3: Full documentation (the help icon) [?] icon with hover text: “Strong passwords include numbers, symbols, and mixed case. Example: MyP@ssw0rd2024”
Why this works:
Power users: See the requirement, meet it, move on
Returning users: Get immediate feedback if they don’t meet it
New users: Get examples and guidance if they’re stuck
The pattern:
Always visible = minimum info to take action
Revealed on interaction = helpful context for those who want it
Accessed by choice = full details for those who need them
Writing techniques for each audience
Key content design strategy by audience:
Audience User state Content goal Avoid New users Explorer (anxious) Context (the why) Jargon, assumed knowledge, unclear consequences Returning users Practitioner (efficient) Reminder (the how) Re-explaining basics, changed labels, forced tutorials Power users Master (fast) Speed (the shortcut) Tooltips, unnecessary confirmations, time taxes
For new users (be generous):
✓ Do:
Explain the why, not just the what
Provide clear consequences: “This will delete 5 files. You can undo this.”
Use complete sentences
Provide examples
Offer reassurance about safety
Set clear expectations
Use familiar words, even if longer
✗ Don’t:
Assume any prior knowledge
Use jargon without definition
Skip context about what happens next
Be clever or cute (clear > clever)
Make them guess if an action is reversible
Example: Instead of: “Toggle notifications” Write: “Choose which notifications you want to receive”
For returning users (be efficient):
✓ Do:
Focus on the key differentiator
Use consistent labels (they remember these)
Provide quick reminders
Respect their existing knowledge
✗ Don’t:
Re-explain basics
Force them through tutorials
Change terminology they’ve learned
Make them read paragraphs for one piece of info
Example: Instead of: “Click here to create a new project. Projects help you organize your work.” Write: “New project” (They know what projects are. Just let them create one.)
For power users (get out of the way):
✓ Do:
Provide keyboard shortcuts
Enable bulk actions
Allow customization
Show power features
Skip confirmations (when safe)
Respect their time (every click costs them)
✗ Don’t:
Explain obvious things
Show tooltips they’ve seen 100x
Force linear flows
Add unnecessary steps or modals
Patronize them
Example: Instead of: [Dialog box] “Are you sure you want to delete? This cannot be undone.” Provide: [Checkbox in settings] “Skip delete confirmation” + [Keyboard shortcut] “⌘+Delete”
Progressive disclosure patterns
Pattern 1: The expandable explanation
Layer 1: The primary goal (the status) “Auto-save: On”
Layer 2: Helpful context (the expanded detail on click/hover) “Auto-save: On Changes are saved every 30 seconds while you work. Last saved: 2 minutes ago”
Layer 3: Full documentation (the help link) “Learn about auto-save and version history →”
Who this serves:
Power users: See “On,” that’s all they need
Returning users: Hover to confirm it’s working
New users: Click through to understand fully
Pattern 2: The contextual help icon
Layer 1: The primary goal (the button) “Export to CSV”
Layer 2: Helpful context (the help icon hover) “Downloads a spreadsheet file (.csv) you can open in Excel or Google Sheets”
Who this serves:
Power users: Ignore the icon, just export
Returning users: Quick reminder of file format
New users: Learn what CSV means
Pattern 3: The smart default with override
Layer 1: The primary goal (the default setting) “Send weekly summary email” [Toggle: ON]
Layer 2: Helpful context (the advanced options link) “Customize →” [Opens detailed settings for frequency, content, timing]
Who this serves:
New users: Get good defaults without decisions
Returning users: Default works fine, they don’t touch it
Power users: Find customization when they want it
Pattern 4: The first-time overlay (show once)
Layer 1: The primary goal (the clean interface for subsequent uses) Clean interface, no overlay
Layer 3: Full documentation (the first-time orientation) [Overlay with arrows pointing to key features] “Here’s how to get started:
Upload files here
Organize them into folders
Share with your team [Got it] [Take a tour] [Skip for now]”
Who this serves:
New users: Guided orientation
Returning users: Don’t see it again
Power users: Never see it (or dismissed it immediately)
Pattern 5: The tiered navigation
Layer 1: The primary goal (the primary menu for everyone)
New project
My projects
Shared with me
Layer 2: Helpful context (the secondary menu for returning users)
Templates
Archived
Trash
Layer 3: Full documentation (the power menu via keyboard or right-click)
Duplicate
Move to...
Export
API access
Who this serves:
New users: Not overwhelmed by options
Returning users: Find additional features as needed
Power users: Access everything quickly via shortcuts
Pattern 6: The guidance-rich empty state
Layer 1: The primary goal (the normal interface once data exists) [Shows normal interface with data]
Layer 3: Full documentation (the empty state guidance for new users) [Empty state with clear instructions] “You don’t have any contacts yet.
Get started by:
Importing from a CSV file
Adding contacts manually
Connecting your email account
[Import contacts] [Add your first contact] [Learn more →]”
Who this serves:
New users: Clear guidance on what to do first, with multiple entry points
Returning/Power users: Never see this again once they have data
Why this works: Empty states are perfect for Layer 3 guidance—they appear exactly when users need help most (when starting out), and disappear once they’re no longer relevant.
Common mistakes to avoid
Mistake #1: One-size-fits-all copy
✗ Writing only for beginners makes experts leave
✗ Writing only for experts makes beginners fail
✓ Layer your information using progressive disclosure
Mistake #2: Feature-announcement overload
✗ “New! Check out our amazing new feature! Click here to learn more!” [For a feature power users already know]
✓ “New: [Feature name]” badge that disappears after first interaction
Mistake #3: Forced onboarding
✗ Making everyone sit through a tutorial
✓ Offer tutorials, don’t require them. “Skip for now” should always be an option
Mistake #4: Unchangeable helpful hints
✗ Showing the same tooltip every single time
✓ “Don’t show this again” checkbox OR auto-hide after 3 views
Mistake #5: Treating returning users like new users
✗ “Welcome back! Let us remind you how everything works...”
✓ “Welcome back, [name]” + jump straight to their work
Mistake #6: Hiding power features completely
✗ Making advanced options so buried power users can’t find them
✓ Progressive disclosure: simple by default, advanced options clearly available
The business case for layering
Layering your copy isn’t just good UX—it drives measurable business outcomes:
Reduces support tickets: Fewer new user errors because they get the context they need upfront
Increases feature adoption: Clearer entry points with appropriate guidance means more people try features successfully
Boosts power user retention: Reduced friction and time tax keeps your most valuable users engaged and productive
Improves onboarding: New users succeed faster with contextual help, reducing drop-off
Scales better: One well-layered interface serves all users, rather than maintaining separate “beginner” and “advanced” modes
When you explain this framework to stakeholders, frame it in these terms. Progressive disclosure isn’t about making things “nicer”—it’s about serving your entire user base efficiently while driving key metrics.
Interactive exercise: Design for all three
Here’s a feature in your product: “Bulk import contacts”
Design copy for all three audiences using progressive disclosure.
Scenario details:
Users can upload a CSV file to import multiple contacts at once
New users might not know what CSV is
The import can fail if the format is wrong
Power users do this weekly
Your task:
Write Layer 1 (the primary button/label - everyone sees this)
Write Layer 2 (hover text or brief description - returning users see this)
Write Layer 3 (help documentation or first-time guidance - new users access this)
Bonus: What keyboard shortcut or power feature would you add?
Instructions: Consider:
What does each audience need to know?
What can you hide until needed?
How do you prevent errors for new users without slowing down power users?
Take 5 minutes to try this before checking the solution.
Exercise solution
Here’s how I’d approach it:
Layer 1: The primary goal (the button label for everyone) “Import contacts”
Layer 2: Helpful context (the hover tooltip for returning users) “Upload a CSV file to add multiple contacts at once”
Layer 3a: Full documentation (the first-time panel) [Panel that appears on first click] “Import contacts from CSV
Upload a spreadsheet file to add many contacts at once. Your file should include columns for name, email, and phone.
[Download sample CSV template] [Upload file] [Learn more about importing →]”
Layer 3b: Full documentation (the help page for new users who need it) “How to import contacts:
Prepare a CSV file with columns: First name, Last name, Email, Phone
Click ‘Import contacts’
Upload your file
Review and confirm
Common issues:
Make sure your file is .csv format (not .xlsx)
Check that email addresses are valid
Remove any empty rows [See example file →]”
Power user features:
Keyboard shortcut: ⌘ + I
Setting: “Auto-map columns” (remembers their CSV format)
Bulk action: “Import and tag” (combines two steps)
Setting: “Skip preview” (imports directly for trusted files)
Why this works:
New users: Get templates, examples, and guidance through Layer 3
Returning users: Quick reminder of format via Layer 2 hover
Power users: Fast access via keyboard shortcut, automation options to reduce time tax
The art of invisible complexity
Great UX writing doesn’t mean writing less. It means showing less while having more available.
Simple for everyone looks different for each person. The new user needs context and safety. The power user needs speed and shortcuts. You can’t give both the same experience.
But you can give both what they need.
The key insight: Layer your information using progressive disclosure so each person gets what they need without seeing what they don’t.
Your action item: Pick one feature in your product. Map out the three audiences:
What do new users struggle with? What consequences worry them?
What do returning users forget?
What do power users wish was faster? What’s their biggest time tax?
Then layer your copy accordingly.
What’s next
Next week, we shift gears. We’ll look at why error messages aren’t writing problems—they’re system design problems. We’ll apply the if-then-else logic to error prevention and show you how to fix the system, not just the copy.
See you Friday.
— Mansi
Your UX Writing Bud
Related reading: Decision logic for different user contexts (combines perfectly with this framework)
The if-then-else framework for UX copy decisions
How to make defensible content choices using logic instead of opinion
Found this useful? Here’s how to apply it:
📬 Send me your layering challenge - Struggling to write for multiple audiences? DM me on Substack with your scenario.
🔗 Share with your team - Forward this to designers and PMs. It helps them understand why one-size-fits-all copy doesn’t work.
💬 Tell me what you tried - Applied the three audiences framework? Reply and let me know what happened.
☕ Support this work - If this framework changed your approach, buy me a coffee/book.
UX Writing Bud delivers frameworks and systems for content designers every Friday. Free, always.