Information Architecture: How Users Find Things

What & Why

Information architecture is the invisible skeleton of every digital product. It determines whether a user can find what they need in 5 seconds or gives up after 5 minutes.

Peter Morville and Louis Rosenfeld defined IA through three circles: users (their needs and behaviors), content (its volume, format, and structure), and context (business goals and constraints). Good IA sits at the intersection of all three.

Why should engineers care? Because every API, every database schema, every navigation menu, and every URL structure is an information architecture decision. A poorly structured REST API is just as hard to navigate as a poorly structured website. The principles are the same: group related things together, label them clearly, and provide multiple paths to the same destination.

How It Works

The Four Systems of IA

Rosenfeld and Morville identified four interconnected systems that make up an information architecture:

Card Sorting

Card sorting is the primary research method for building an organization system. You write each content item on a card (physical or digital) and ask participants to group them.

There are three variants:

• Open card sort: Participants create their own group names. Reveals how users naturally categorize content.
• Closed card sort: Groups are predefined. Tests whether an existing taxonomy makes sense to users.
• Hybrid card sort: Some groups are predefined, but participants can create new ones.

Analysis of card sort results uses a similarity matrix: for each pair of cards, count how many participants placed them in the same group. High similarity scores suggest those items belong together.

Tree Testing

Tree testing validates the structure that card sorting helped create. You present participants with a text-only hierarchy (no visual design, no search) and ask them to find specific items. This isolates the IA from visual design influences.

Key metrics from tree testing:

• Task success rate: percentage of participants who found the correct item
• Directness: percentage who navigated to the answer without backtracking
• Time to find: how long it took to locate the item

A findability score below 60% for any task signals a structural problem that needs redesign.

Navigation Patterns

Navigation systems come in several standard patterns, each suited to different content structures:

• Hierarchical: The most common pattern. Content is organized in a tree. Works well when categories are clear and mutually exclusive. Risk: deep hierarchies (more than 3-4 levels) cause users to get lost.
• Faceted: Users filter along multiple dimensions simultaneously. Ideal for e-commerce and large catalogs. Each facet is independent, so users can combine filters freely.
• Sequential: A linear path through content. Used for onboarding flows, checkout processes, and tutorials. Works when order matters.
• Hub-and-spoke: A central hub links to independent sections. Common in mobile apps (tab bar as hub) and dashboards. Each spoke is self-contained.

Complexity Analysis

IA research methods have different cost and coverage characteristics:

The similarity score between two cards $i$ and $j$ across $p$ participants is:

This produces a value in $[0, 1]$. A similarity matrix for $n$ cards has $\binom{n}{2} = \frac{n(n-1)}{2}$ unique pairs. For 50 cards, that is 1,225 pairs to analyze.

Tree test findability for a task $t$ is:

Directness (no backtracking) is a stricter metric:

Implementation

ALGORITHM BuildSimilarityMatrix(cardSortResults)
  INPUT: cardSortResults: array of participant results,
         each result is a map of { cardId -> groupName }
  OUTPUT: similarity matrix S where S[i][j] = proportion of
          participants who grouped card i with card j

  cards ← unique set of all cardIds across all results
  n ← |cards|
  p ← |cardSortResults|
  S ← n x n matrix initialized to 0

  FOR EACH result IN cardSortResults DO
    groups ← invert result to { groupName -> set of cardIds }
    FOR EACH group IN groups DO
      cardList ← group.cards as array
      FOR i FROM 0 TO |cardList| - 2 DO
        FOR j FROM i + 1 TO |cardList| - 1 DO
          S[cardList[i]][cardList[j]] ← S[cardList[i]][cardList[j]] + 1
          S[cardList[j]][cardList[i]] ← S[cardList[j]][cardList[i]] + 1
        END FOR
      END FOR
    END FOR
  END FOR

  FOR EACH i IN cards DO
    FOR EACH j IN cards DO
      S[i][j] ← S[i][j] / p
    END FOR
  END FOR

  RETURN S
END ALGORITHM

ALGORITHM EvaluateTreeTest(tasks, userPaths, correctAnswers)
  INPUT: tasks: list of task descriptions,
         userPaths: map of { taskId -> array of user navigation paths },
         correctAnswers: map of { taskId -> correct node }
  OUTPUT: findability report per task

  report ← empty list

  FOR EACH task IN tasks DO
    paths ← userPaths[task.id]
    correct ← correctAnswers[task.id]
    successCount ← 0
    directCount ← 0
    totalTime ← 0

    FOR EACH path IN paths DO
      IF path.finalNode = correct THEN
        successCount ← successCount + 1
        IF path.backtracks = 0 THEN
          directCount ← directCount + 1
        END IF
      END IF
      totalTime ← totalTime + path.duration
    END FOR

    u ← |paths|
    report.append({
      task: task.description,
      findability: successCount / u * 100,
      directness: directCount / u * 100,
      avgTime: totalTime / u,
      needsRedesign: (successCount / u * 100) < 60
    })
  END FOR

  RETURN report
END ALGORITHM

ALGORITHM SuggestNavPattern(contentProfile)
  INPUT: contentProfile: { totalItems, maxDepth, hasFacets,
                           isSequential, isIndependent }
  OUTPUT: recommended navigation pattern

  IF contentProfile.isSequential THEN
    RETURN "Sequential (wizard/stepper)"
  END IF

  IF contentProfile.hasFacets AND contentProfile.totalItems > 100 THEN
    RETURN "Faceted navigation with search"
  END IF

  IF contentProfile.isIndependent AND contentProfile.maxDepth <= 2 THEN
    RETURN "Hub-and-spoke (tab bar or dashboard)"
  END IF

  IF contentProfile.maxDepth <= 3 THEN
    RETURN "Hierarchical with breadcrumbs"
  END IF

  RETURN "Hierarchical with search and breadcrumbs"
END ALGORITHM

Real-World Applications

• E-commerce faceted search: Amazon's left sidebar lets users filter by department, price, rating, and brand simultaneously. Each facet is an independent axis of the taxonomy
• GitHub repository structure: Code, Issues, Pull Requests, Actions, and Settings form a hub-and-spoke pattern with the repository as the hub
• Wikipedia's category system: A massive hierarchical taxonomy with cross-links, demonstrating both the power and the messiness of large-scale IA
• Spotify's browse structure: Combines hierarchical (genres > subgenres) with faceted (mood, activity, decade) and algorithmic (personalized playlists) navigation
• REST API design: URL paths like /users/123/orders/456 are hierarchical IA. Good API design follows the same principles as good site navigation
• File system design: The Unix directory tree is a hierarchical IA. The perennial debate about flat vs. nested folder structures is an IA problem
• Slack's channel organization: Teams that use prefixes like #proj-, #team-, #help- are applying taxonomy design to chat channels
• Notion's sidebar: A hierarchical tree of pages and databases that users can nest arbitrarily deep. Works well for small workspaces but becomes unwieldy past 3-4 levels, illustrating the depth vs. breadth trade-off
• iOS Settings app: A deep hierarchical navigation (Settings > General > About > Name) that uses breadcrumb-style back buttons. Frequent tree testing by Apple keeps findability high despite the depth
• Stripe's documentation: Combines hierarchical navigation (sidebar tree), search, and breadcrumbs. The three systems reinforce each other so users can find content regardless of their preferred navigation style

Key Takeaways

• Information architecture is the structural design of content: how things are organized, labeled, and connected. It is invisible when done well and painful when done poorly
• Card sorting reveals how users naturally group content. Open sorts discover categories, closed sorts validate them
• Tree testing measures findability in isolation from visual design. A findability score below 60% means the structure needs work
• The four IA systems (organization, labeling, navigation, search) must work together. Strong search cannot compensate for broken navigation, and vice versa
• Navigation patterns (hierarchical, faceted, sequential, hub-and-spoke) are not mutually exclusive. Most products combine several
• Good IA reduces cognitive load by matching the structure to users' mental models, not to the organization's internal structure