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:
- Use established IA methodology (Rosenfeld & Morville, Abby Covert)
- Base all guidance on validated IA practices
IA Foundations
The Four Systems of IA
| System | Question Answered | Components | |--------|-------------------|------------| | Organization | How is content grouped? | Schemes, structures, taxonomies | | Labeling | What do we call things? | Labels, terminology, naming | | Navigation | How do users move around? | Menus, links, breadcrumbs | | Search | How do users find specific items? | Search UI, indexing, results |
IA Deliverables
| Deliverable | Purpose | When | |-------------|---------|------| | Content Inventory | Audit existing content | Discovery | | Site Map | Hierarchical structure | Design | | Taxonomy | Classification scheme | Design | | Navigation Model | Menu and wayfinding | Design | | Wireframes | Page-level IA | Design | | Card Sort Results | User mental models | Validation | | Tree Test Results | Findability validation | Validation |
Organization Systems
Organization Schemes
| Scheme | Description | Example | |--------|-------------|---------| | Exact | Objectively defined | Alphabetical, chronological, geographical | | Ambiguous | Subjectively defined | By topic, audience, task, metaphor | | Hybrid | Combination | Primary navigation + search + filters |
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
| Depth | Use Case | Considerations | |-------|----------|----------------| | Flat (2-3) | Simple sites, mobile | Easy to scan, limited content | | Medium (4-5) | Most websites | Balance breadth/depth | | Deep (6+) | Large catalogs, documentation | Risk of getting lost |
Rule of thumb: Prefer broader over deeper. Users can scan 5-7 items quickly.
Card Sorting
Card Sort Types
| Type | Description | Best For | |------|-------------|----------| | Open | Users create their own categories | Discovery, understanding mental models | | Closed | Users sort into predefined categories | Validating proposed structure | | Hybrid | Predefined categories + can add new | Validating with flexibility |
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
| Metric | Definition | Target | |--------|------------|--------| | Success Rate | Found correct answer | >80% | | Directness | Found without backtracking | >60% | | Time | Seconds to complete | Task-dependent | | First Click | Correct first navigation | >60% |
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
| Pattern | Indication | Solution | |---------|------------|----------| | Low success, low directness | Wrong location in hierarchy | Restructure | | Low success, high first-click | Right area, wrong label | Rename | | High success, low directness | Findable but confusing path | Simplify | | Split decisions | Ambiguous placement | Cross-reference or restructure |
Navigation Design
Navigation Types
| Type | Purpose | Example | |------|---------|---------| | Global | Site-wide access | Header menu | | Local | Section-specific | Sidebar in current area | | Contextual | Content-related | "Related items" links | | Utility | Tools/account | Login, cart, help | | Footer | Secondary access | Policies, contact | | Breadcrumbs | Location awareness | Home > Products > Shoes |
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
| Pattern | When to Use | |---------|-------------| | Hamburger | Complex nav, frequent users | | Tab Bar | 3-5 primary destinations | | Bottom Sheet | Secondary actions | | Progressive Disclosure | Deep hierarchies |
Labeling Systems
Label Evaluation Criteria
| Criterion | Question | Test | |-----------|----------|------| | Clarity | Is meaning obvious? | 5-second test | | Consistency | Same concept = same label? | Content audit | | Completeness | All content labeled? | Gap analysis | | Audience-fit | Uses user language? | Card sort, interviews |
Label Testing Methods
- Highlight Test - Can users identify what label refers to?
- Cloze Test - Fill in the blank with expected label
- Card Sort - What do users call these groups?
- First-Click Test - Do users click correct label for task?
Common Labeling Problems
| Problem | Example | Solution | |---------|---------|----------| | Jargon | "SKU Manager" | Use user language: "Product Catalog" | | Ambiguity | "Resources" | Be specific: "Documentation", "Downloads" | | Overlap | "Support" vs "Help" | Consolidate or differentiate | | Inconsistency | "Docs" / "Documentation" / "Help Files" | Standardize |
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
| ID | Page Name | Parent | Level | URL Pattern | Template | Notes | |----|-----------|--------|-------|-------------|----------|-------| | 1 | Home | - | 0 | / | Homepage | | | 2 | Products | 1 | 1 | /products | Category Listing | | | 3 | Category A | 2 | 2 | /products/{slug} | Category | Dynamic | | 4 | Product Detail | 3 | 3 | /products/{cat}/{slug} | PDP | Dynamic |
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 planningusability-testing- Testing navigationaccessibility-planning- Accessible navigation patternsservice-blueprinting- Service touchpoint structure