← Build log

Information Architecture as Product Strategy: Essential → History → Advanced

How Feature Ordering Drives User Adoption and Prevents Feature Burial

By: Jeremy (TPM learning that IA decisions have business consequences)

Here’s a mistake I see TPMs make constantly: We treat information architecture like a design decision when it’s actually a product strategy decision.

The placement and ordering of features in your interface isn’t about aesthetics—it’s about adoption rates, user workflows, and ultimately, whether your features get used or buried. This is the story of how a simple ordering decision in VoiceCatcher’s settings panel taught me that every pixel placement is a business decision.

The Setup: Where Do You Put History Access?

Context: We’d just built our popup history window (see previous posts about the architecture decision). Now we needed to decide where in the main UI users would access it.

The main settings panel has three expandable sections. The question: What order should they be in?

As a TPM, my first instinct was functional grouping:

  • Configuration (appearance, settings)
  • History (view sessions, export data)
  • Advanced (power user features)

Logical, right? Related functions grouped together, complexity increasing as you go down.

I was completely wrong.

The Frequency-First Principle: Usage Drives Architecture

The Realization

While testing the feature myself, I noticed something: I accessed history 3-4 times per session, but only touched advanced settings once per week.

If I was checking history that frequently, why was I burying it below a bunch of configuration options I rarely needed?

This led to a fundamental reframe: Information architecture should optimize for usage frequency, not logical categorization.

The New Framework: Essential → History → Advanced

Essential Settings (accessed multiple times per session):

  • Auto-paste toggle
  • Appearance/theme
  • Hotkey configuration
  • Silence timeout

History (accessed 1-3 times per session):

  • View session history
  • Export capabilities
  • History management

Advanced (accessed once per week or less):

  • Timestamps toggle
  • Playback controls
  • Start at login
  • Silence threshold fine-tuning

The TPM Framework: Frequency-Based Information Architecture

1. Map Actual Usage Patterns

Don’t guess at frequency—measure or observe it.

The Prompt I Used:

Help me analyze feature usage patterns for information architecture:

For each feature, estimate:
1. How often is this used per user session?
2. What triggers a user to need this feature?
3. Is this a setup-once feature or recurring-use feature?
4. Does usage of this feature block other workflows?

Features: [list your features]

2. Apply the Frequency Hierarchy

Multiple times per session → Top section
Once per session → Middle section
Once per week → Bottom section
Once per setup → Separate/buried location

3. Validate with Workflow Mapping

The Validation Prompt:

Given this feature ordering: [your proposed order]
Walk through these user scenarios:
1. Daily power user workflow
2. New user first week
3. Returning user after month away
4. User troubleshooting an issue

Does the ordering support or hinder each workflow?

The Business Impact: When IA Drives Adoption

Before: Logical Grouping

  • History buried in third section
  • Users didn’t discover review capabilities
  • Sessions felt like “fire and forget”
  • Limited engagement with transcription quality

After: Frequency-Based Ordering

  • History prominently placed in second section
  • Users naturally discovered session review
  • Increased engagement with output quality
  • Users started building workflows around history

The Adoption Metrics

While I don’t have formal analytics (solo developer problems), the behavioral changes were obvious:

  • Discovery time: From 2-3 days to immediate
  • Usage frequency: From “never” to 2-3 times per session
  • User feedback: “I didn’t know this existed” → “This is exactly what I needed”

Common TPM IA Mistakes (That I Made)

Mistake 1: Engineer Logic Over User Workflow

What we think: “Related features should be grouped together” User reality: “I need frequent features to be easy to find”

Fix: Optimize for workflow frequency, not logical similarity.

Mistake 2: Democracy in Feature Placement

What we think: “All features deserve equal prominence” User reality: “Some features are way more important than others”

Fix: Create clear visual and positional hierarchy based on usage data.

Mistake 3: Power User Bias

What we think: “Advanced users will find everything eventually” User reality: “Most users never explore past the first section”

Fix: Optimize for 80% use cases in the first section, 15% in the second, 5% in the third.

Mistake 4: Feature Equality Assumption

What we think: “Every feature we built deserves to be discoverable” User reality: “I just want to get my job done with minimal friction”

Fix: Accept that some features should be buried. That’s not failure—that’s appropriate prioritization.

The Technical Implementation: How IA Becomes Code

Here’s where information architecture decisions become product decisions:

Visual Weight Distribution

/* Essential: Full visual prominence */
.essential-section {
  border: 2px solid var(--primary);
  box-shadow: var(--elevated);
}

/* History: Medium prominence */
.history-section {
  border: 1px solid var(--secondary);
  box-shadow: var(--standard);
}

/* Advanced: Minimal prominence */
.advanced-section {
  border: 1px solid var(--muted);
  box-shadow: var(--subtle);
}

Expansion Behavior

// One section open at a time forces prioritization
const [openSection, setOpenSection] = useState<'essential' | 'history' | 'advanced'>('essential');

// Essential section starts open = immediate access to most-used features

Coming Soon Roadmap Placement

Even “coming soon” features follow frequency hierarchy:

  • History section: Export, History retention, Disable history (user-requested frequently)
  • Advanced section: Start at login (rarely requested)

Advanced: The Progressive Disclosure Strategy

Layer 1: Essential Actions

The 20% of features that drive 80% of user value:

  • Core functionality toggles
  • Appearance customization
  • Primary hotkey configuration

Layer 2: Workflow Enhancement

The 30% of features that enhance core workflows:

  • History access and management
  • Session organization
  • Data export capabilities

Layer 3: Power User Customization

The 50% of features that serve edge cases:

  • Fine-tuning parameters
  • Advanced configurations
  • Developer/debug features

The Prompts That Drive Better IA Decisions

Feature Frequency Analysis Prompt

I need to organize these features in a user interface: [feature list]

For each feature, analyze:
1. Usage frequency (per session, per day, per week)
2. User intent when accessing (core workflow vs troubleshooting vs customization)
3. Cognitive overhead (simple toggle vs complex configuration)
4. Prerequisites (needs other features to be useful?)

Suggest an information architecture that optimizes for workflow efficiency.

Workflow Validation Prompt

Given this proposed feature organization: [your IA structure]

Test it against these scenarios:
1. New user trying to accomplish [primary use case]
2. Daily user accessing their most common features
3. Power user customizing their setup
4. User troubleshooting [common problem]

Identify friction points and suggest improvements.

Progressive Disclosure Design Prompt

I have [X] features that need to be accessible but can't all be equally prominent.

Design a progressive disclosure system that:
1. Puts highest-frequency features in primary interface
2. Makes secondary features discoverable but not cluttered
3. Hides advanced features until needed
4. Maintains clear mental model of where things are

Include specific UI patterns and interaction design.

The Business Psychology: Why This Matters

Cognitive Load Management

Every feature placement decision affects cognitive load. Users can handle ~7±2 items in primary view before feeling overwhelmed.

IA Strategy: Front-load the 3-5 most critical features, progressive disclosure for everything else.

Adoption Path Creation

Feature placement creates natural adoption paths. Users explore in order from top to bottom, most prominent to least prominent.

IA Strategy: Order features by “workflow progression”—what features do users need in sequence to build habits?

Perceived Complexity Management

Users judge product complexity by the first interface they see, not by total feature count.

IA Strategy: Keep first-view simple even if the product is complex. Advanced complexity should be opt-in, not default.

Tools and Techniques for TPMs

Usage Heat Mapping (Without Analytics)

Even without formal analytics, you can map usage patterns:

  • Track your own behavior for a week
  • Note which features you access in sequence
  • Time how long it takes to complete common workflows
  • Identify features you “discover” late vs use immediately

Paper Prototype Testing

Before implementing, sketch different IA approaches:

  • Draw each layout option
  • Walk through user scenarios on paper
  • Time each approach
  • Note where you get confused or frustrated

The 30-Second Test

Can a new user accomplish the primary use case in 30 seconds from first launch?

  • If no, your primary features aren’t prominent enough
  • If yes, test secondary use cases at 2-minute mark

Lessons Learned: IA as Competitive Advantage

Information Architecture is Product Differentiation

Two apps with identical features can have vastly different user experiences based purely on IA decisions.

VoiceCatcher example: Our Essential → History → Advanced ordering makes history feel like a core feature rather than an afterthought. Competitors bury history in submenus.

IA Decisions Compound Over Time

Good IA makes users more successful, which drives retention and word-of-mouth.

Compounding effect: Users who discover history features early become power users who request advanced features, driving product evolution.

Poor IA is Hard to Fix Later

Users build mental models quickly. Changing feature locations breaks established workflows.

Prevention strategy: Get IA right early by optimizing for frequency and workflow rather than logical grouping.

The Meta-Lesson: Every Placement is a Product Decision

The biggest insight from this experience: There are no neutral interface decisions.

Every choice about feature placement is a choice about:

  • Which workflows you’re optimizing for
  • Which users you’re prioritizing
  • Which features you want to drive adoption for
  • What mental model you want users to develop

As TPMs, we need to approach IA decisions with the same rigor we apply to roadmap prioritization—because that’s exactly what IA is: spatial roadmap prioritization.

Practical Implementation for TPMs

Start With Frequency Audits

Before designing any interface, map actual usage frequency for every feature. Don’t guess—observe.

Design for the 80/20 Rule

80% of interface prominence should go to 20% of features (the most frequently used ones).

Test Early and Often

IA mistakes are expensive to fix after users have formed habits. Test with real workflows, not just feature checklists.

Accept Feature Inequality

Not every feature deserves equal prominence. That’s not design failure—that’s appropriate prioritization.

The Bottom Line

Information architecture isn’t visual design—it’s product strategy expressed through spatial relationships.

The Essential → History → Advanced ordering in VoiceCatcher wasn’t just about making things look organized. It was about driving adoption of our history features, creating natural workflow progressions, and optimizing for how users actually work rather than how we think they should work.

As TPMs, we need to recognize that every pixel placement is a business decision. The space closest to the user’s first click is your most valuable real estate. Spend it wisely.

The users who find and use your features are the users who become advocates for your product. Information architecture determines which users find which features.

Get the IA right, and features sell themselves. Get it wrong, and even great features remain buried.

Jeremy is a technical product manager turned solo developer, building VoiceCatcher as a local-first voice transcription tool. Follow the journey at [project repo] or connect on [social links].

Next in this series: “The Neumorphic Design System: Technical Consistency as User Experience” - How shared CSS architecture enabled multi-window UI consistency and why design systems are infrastructure decisions.