Information Architecture

Information Architecture

Design and validate information structures that help users find and understand content.

When to Use This Skill

Use this skill when:

• Information Architecture tasks - Working on design information architecture - site structure, navigation, card sorting, tree testing, taxonomy, labeling systems, and findability
• Planning or design - Need guidance on Information Architecture approaches
• Best practices - Want to follow established patterns and standards

MANDATORY: Skill Loading First

Before answering ANY information architecture question:

2. Use established IA methodology (Rosenfeld & Morville, Abby Covert)
3. Base all guidance on validated IA practices

IA Foundations

The Four Systems of IA

IA Deliverables

Organization Systems

Organization Schemes

Organization Structures

graph TD
    subgraph Hierarchical
    A[Top] --> B[Category 1]
    A --> C[Category 2]
    B --> D[Sub 1.1]
    B --> E[Sub 1.2]
    end

    subgraph Database
    F[(Products)] --> G[Filters]
    F --> H[Sort]
    F --> I[Search]
    end

    subgraph Hypertext
    J[Page A] <--> K[Page B]
    K <--> L[Page C]
    L <--> J
    end

Hierarchy Depth Guidelines

Rule of thumb: Prefer broader over deeper. Users can scan 5-7 items quickly.

Card Sorting

Card Sort Types

Running a Card Sort

Preparation

// Card sort configuration
public class CardSortStudy
{
    public Guid Id { get; init; }
    public required string Name { get; init; }
    public required CardSortType Type { get; init; }
    public required List<Card> Cards { get; init; }
    public List<Category>? PredefinedCategories { get; init; } // For closed/hybrid
    public bool AllowNewCategories { get; init; } // For hybrid
    public int TargetParticipants { get; init; } = 30;
}

public record Card(int Id, string Label, string? Description = null);
public record Category(int Id, string Name, string? Description = null);

public class CardSortResult
{
    public required Guid ParticipantId { get; init; }
    public required List<CategoryAssignment> Assignments { get; init; }
    public required List<Category> CreatedCategories { get; init; } // Open/hybrid
    public TimeSpan Duration { get; init; }
    public string? Feedback { get; init; }
}

public record CategoryAssignment(int CardId, int CategoryId, int? SortOrder = null);

Card Selection Guidelines

• 15-40 cards typical for open sort
• 30-60 cards manageable for closed sort
• Use real content labels, not placeholders
• Include mix of "easy" and "difficult" items
• Avoid duplicate concepts

Card Sort Analysis

Similarity Matrix

Shows how often cards were sorted together:

         Card A  Card B  Card C  Card D
Card A     -      85%     12%     45%
Card B    85%      -      10%     50%
Card C    12%     10%      -      90%
Card D    45%     50%     90%      -

Cards frequently sorted together should likely be grouped.

Dendrogram (Hierarchical Clustering)

              |
      ________|________
      |               |
   ___|___         ___|___
   |     |         |     |
Card A  Card B  Card C  Card D

Shows natural groupings and relationships.

Category Analysis

For open sorts, analyze:

• Category names - What labels do users create?
• Category frequency - How many users created similar categories?
• Standardized categories - Group similar labels together

public class CardSortAnalysis
{
    public required int TotalParticipants { get; init; }
    public required Dictionary<(int CardA, int CardB), decimal> SimilarityMatrix { get; init; }
    public required List<DendrogramNode> Dendrogram { get; init; }
    public required List<CategoryPattern> DiscoveredPatterns { get; init; }
    public required List<ProblematicCard> DifficultCards { get; init; }
}

public record CategoryPattern(
    string StandardizedName,
    List<string> Variations,
    List<int> CardIds,
    int Frequency
);

public record ProblematicCard(
    int CardId,
    string Label,
    decimal Disagreement, // How often it was sorted inconsistently
    string Issue // "Ambiguous label", "Fits multiple categories", etc.
);

Tree Testing

What is Tree Testing?

Users navigate a text-only version of your hierarchy to find items. No visual design, just structure.

Running a Tree Test

public class TreeTestStudy
{
    public Guid Id { get; init; }
    public required string Name { get; init; }
    public required TreeNode Root { get; init; }
    public required List<TreeTestTask> Tasks { get; init; }
    public int TargetParticipants { get; init; } = 50;
}

public class TreeNode
{
    public int Id { get; init; }
    public required string Label { get; init; }
    public List<TreeNode> Children { get; init; } = [];
    public bool IsCorrectAnswer { get; set; } // For current task
}

public class TreeTestTask
{
    public required int Order { get; init; }
    public required string TaskDescription { get; init; }
    public required List<int> CorrectAnswerPaths { get; init; } // Multiple valid paths
}

public class TreeTestResult
{
    public required Guid ParticipantId { get; init; }
    public required int TaskId { get; init; }
    public required List<int> PathTaken { get; init; }
    public required int FinalSelection { get; init; }
    public required bool IsDirectSuccess { get; init; } // Found it first try
    public required bool IsIndirectSuccess { get; init; } // Found after backtracking
    public required TimeSpan Duration { get; init; }
}

Tree Test Metrics

Pietree Analysis

Visualize where users went for each task:

Task: "Find return policy"

Customer Service [45%] ✓ Correct path
├── Returns [40%] ✓
├── FAQ [3%]
└── Contact [2%]

Help [30%]
├── FAQ [20%]
└── Contact [10%]

Account [15%] ✗ Wrong tree
└── Order History [15%]

About [10%] ✗ Wrong tree
└── Policies [10%]

Identifying Problems

Navigation Design

Navigation Types

Navigation Patterns

// Navigation model
public class NavigationStructure
{
    public required List<NavItem> GlobalNav { get; init; }
    public required List<NavItem> UtilityNav { get; init; }
    public required List<NavItem> FooterNav { get; init; }
    public Dictionary<string, List<NavItem>> LocalNav { get; init; } = [];
}

public class NavItem
{
    public required string Label { get; init; }
    public required string Url { get; init; }
    public List<NavItem>? Children { get; init; }
    public bool IsCurrentSection { get; set; }
    public string? Icon { get; init; }
    public NavItemType Type { get; init; } = NavItemType.Link;
}

public enum NavItemType
{
    Link,
    Dropdown,
    Megamenu,
    Flyout,
    Button // For CTAs like "Sign Up"
}

Mega Menu Structure

For sites with many categories:

┌─────────────────────────────────────────────────────┐
│ PRODUCTS ▼                                          │
├─────────────────────────────────────────────────────┤
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐  │
│ │ Category A   │ │ Category B   │ │ Category C   │  │
│ │ - Sub A1     │ │ - Sub B1     │ │ - Sub C1     │  │
│ │ - Sub A2     │ │ - Sub B2     │ │ - Sub C2     │  │
│ │ - Sub A3     │ │ - Sub B3     │ │ - Sub C3     │  │
│ │ > View All   │ │ > View All   │ │ > View All   │  │
│ └──────────────┘ └──────────────┘ └──────────────┘  │
│                                                      │
│ [Featured: Spring Collection]  [Featured: New]      │
└─────────────────────────────────────────────────────┘

Mobile Navigation Considerations

Labeling Systems

Label Evaluation Criteria

Label Testing Methods

1. Highlight Test - Can users identify what label refers to?
2. Cloze Test - Fill in the blank with expected label
3. Card Sort - What do users call these groups?
4. First-Click Test - Do users click correct label for task?

Common Labeling Problems

Taxonomy Design

Taxonomy Structure

public class Taxonomy
{
    public Guid Id { get; init; }
    public required string Name { get; init; }
    public required TaxonomyType Type { get; init; }
    public required List<TaxonomyTerm> Terms { get; init; }

    public TaxonomyTerm? FindTerm(string label) =>
        Terms.SelectMany(Flatten).FirstOrDefault(t => t.Label == label);

    private IEnumerable<TaxonomyTerm> Flatten(TaxonomyTerm term) =>
        new[] { term }.Concat(term.Children.SelectMany(Flatten));
}

public enum TaxonomyType
{
    Hierarchical,   // Tree structure
    Faceted,        // Multiple dimensions
    Network,        // Many-to-many relationships
    Flat            // No hierarchy
}

public class TaxonomyTerm
{
    public int Id { get; init; }
    public required string Label { get; init; }
    public string? Definition { get; init; }
    public List<string> Synonyms { get; init; } = [];
    public List<TaxonomyTerm> Children { get; init; } = [];
    public int? ParentId { get; init; }
    public List<int> RelatedTermIds { get; init; } = [];
}

Faceted Classification

Multiple ways to categorize the same content:

Product: "Blue Running Shoes"

Facets:
├── Category: Footwear > Athletic > Running
├── Color: Blue
├── Brand: Nike
├── Price: $100-150
├── Size: 10
├── Gender: Men's
└── Activity: Running, Walking

Site Map Documentation

Visual Site Map

Home
├── Products
│   ├── Category A
│   │   ├── Subcategory A1
│   │   └── Subcategory A2
│   └── Category B
├── About
│   ├── Company
│   ├── Team
│   └── Careers
├── Blog
│   └── [Dynamic: Post pages]
└── Contact

Utility:
├── Search
├── Account
│   ├── Profile
│   ├── Orders
│   └── Settings
└── Cart

Site Map Spreadsheet

IA Auditing

Content Inventory Template

| URL | Title | Type | Category | Last Updated | Owner | Notes |
|-----|-------|------|----------|--------------|-------|-------|
| /about | About Us | Page | Company | 2024-01-15 | Marketing | Needs update |
| /blog/post-1 | Post Title | Blog | News | 2024-02-01 | Editor | Current |

IA Evaluation Checklist

• Organization: Is grouping logical and consistent?
• Labeling: Are labels clear and user-centered?
• Navigation: Can users orient themselves?
• Search: Does search return relevant results?
• Findability: Can users complete key tasks?
• Scalability: Will structure handle growth?

.NET IA Tools

// Generate sitemap from content model
public class SitemapGenerator
{
    public XDocument GenerateXmlSitemap(IEnumerable<ContentItem> content)
    {
        var urlset = new XElement(
            XName.Get("urlset", "http://www.sitemaps.org/schemas/sitemap/0.9"),
            content.Select(item => new XElement("url",
                new XElement("loc", item.CanonicalUrl),
                new XElement("lastmod", item.ModifiedDate.ToString("yyyy-MM-dd")),
                new XElement("changefreq", GetChangeFrequency(item.Type)),
                new XElement("priority", GetPriority(item.Depth))
            ))
        );

        return new XDocument(
            new XDeclaration("1.0", "UTF-8", null),
            urlset
        );
    }

    private static string GetChangeFrequency(ContentType type) => type switch
    {
        ContentType.Homepage => "daily",
        ContentType.Blog => "weekly",
        ContentType.Product => "weekly",
        _ => "monthly"
    };

    private static decimal GetPriority(int depth) => depth switch
    {
        0 => 1.0m,
        1 => 0.8m,
        2 => 0.6m,
        _ => 0.4m
    };
}

Related Skills

• user-research-planning - Card sort and tree test planning
• usability-testing - Testing navigation
• accessibility-planning - Accessible navigation patterns
• service-blueprinting - Service touchpoint structure