Card Sorting for Information Architecture

In this tutorial, you will learn about Card Sorting for Information Architecture. We cover key concepts, practical examples, and best practices to help you master this topic.

Card sorting reveals how users expect content to be organized. Learn open, closed, and hybrid card sorting methods, analysis techniques, and how to apply results.

What You'll Learn

You will learn the three types of card sorting, how to plan and conduct a card sort, how to analyze results, and how to use findings to design taxonomy.

Why It Matters

Designers and users think about content differently. Card sorting reveals the user's mental model, not the designer's.

Real-World Use

DodaTech used card sorting to validate its category structure. Users consistently grouped topics differently than the team expected, leading to a reorganization.

flowchart LR
  A[Card Sorting] --> B[Open Sort]
  A --> C[Closed Sort]
  A --> D[Hybrid Sort]
  B --> E[Users Create Categories]
  C --> F[Users Use Given Categories]
  D --> G[Users Can Add Categories]
  B --> H[Analysis]
  H --> I[Dendrogram]
  H --> J[Similarity Matrix]
  I:::current
  classDef current fill:#f90,color:#fff,stroke:#333,stroke-width:2px

Types of Card Sorting

Open Card Sort

Users create their own categories and name them.

## Open Card Sort Process

1. Prepare 30-60 cards (content topics)
2. Give cards to participants
3. Ask: "Group these cards into categories that make sense"
4. Ask: "Name each category"
5. Repeat with 15-20 participants

Best for: New projects where you have no existing taxonomy.

Closed Card Sort

Users place cards into predefined categories.

## Closed Card Sort Process

1. Prepare cards and predefined category names
2. Give cards to participants
3. Ask: "Place each card into the best category"
4. Note which cards are hard to place
5. Repeat with 20-30 participants

Best for: Validating an existing or proposed taxonomy.

Hybrid Card Sort

Users place cards into predefined categories or create new ones.

def analyze_card_sort(results, method='open'):
    from collections import defaultdict
    
    if method == 'closed':
        # Check how often cards were placed in each category
        card_categories = defaultdict(lambda: defaultdict(int))
        for participant in results:
            for card, category in participant.items():
                card_categories[card][category] += 1
        
        # Find cards with no clear category
        ambiguous = []
        for card, categories in card_categories.items():
            top_category, count = max(categories.items(), key=lambda x: x[1])
            agreement = count / len(results)
            if agreement < 0.5:
                ambiguous.append(card)
        return ambiguous
    
    return []

# Simulated results
results = [
    {'Python Variables': 'Basics', 'Encryption': 'Security'},
    {'Python Variables': 'Getting Started', 'Encryption': 'Security'},
]
print(analyze_card_sort(results, 'closed'))

Expected output:

['Python Variables']

Planning a Card Sort

Card Selection

Choose 30-60 cards that represent your content scope.

def select_cards(all_topics, max_cards=50):
    import random
    if len(all_topics) <= max_cards:
        return all_topics
    
    # Ensure diverse coverage
    stratified = []
    categories = group_by_category(all_topics)
    per_category = max_cards // len(categories)
    for cat, topics in categories.items():
        selected = random.sample(topics, min(per_category, len(topics)))
        stratified.extend(selected)
    
    return stratified[:max_cards]

topics = ['Python Variables', 'Python Loops', 'Encryption', 'Auth', 'Docker']
print(len(select_cards(topics, 3)))

Expected output:

3

Participant Selection

Analyzing Results

Similarity Matrix

Shows how often two cards were placed in the same category.

          PythonVar PythonLoops Encrypt Auth Docker
PythonVar   100%       80%       10%     5%   10%
PythonLoops  80%      100%       15%    10%   15%
Encrypt      10%       15%      100%    70%   60%

Dendrogram

A tree diagram showing how cards cluster together.

def create_similarity_matrix(results, cards):
    import pandas as pd
    matrix = pd.DataFrame(0, index=cards, columns=cards)
    
    for participant in results:
        categories = {}
        for card, cat in participant.items():
            if cat not in categories:
                categories[cat] = []
            categories[cat].append(card)
        
        for cat, group in categories.items():
            for c1 in group:
                for c2 in group:
                    matrix.loc[c1, c2] += 1
    
    # Convert to percentages
    matrix = matrix / len(results) * 100
    return matrix

cards = ['Python Variables', 'Python Loops', 'Encryption']
results = [
    {'Python Variables': 'Basics', 'Python Loops': 'Basics', 'Encryption': 'Security'},
    {'Python Variables': 'Basics', 'Python Loops': 'Basics', 'Encryption': 'Security'},
]
matrix = create_similarity_matrix(results, cards)
print(matrix)

Common Mistakes

1. Too Few Cards

Less than 20 cards does not produce meaningful results. Use 30-60 cards.

2. Too Few Participants

Open sorts need 15-20 participants. Closed sorts need 20-30 participants.

3. Leading the Participants

Telling users how you expect them to group cards defeats the purpose. Let them organize freely.

4. Ignoring Ambiguous Cards

Cards that users consistently place in different categories need clarification or restructuring.

5. Overanalyzing Results

Card sorting reveals trends, not absolute answers. Use results as input, not as the final decision.

Practice Questions

1. What are the three types of card sorting?

Open, closed, and hybrid.

2. When would you use an open card sort?

When designing a new taxonomy from scratch and you need to understand how users naturally group content.

3. How many participants are needed for a closed card sort?

20-30 participants for statistically meaningful results.

4. What does a similarity matrix show?

How often two cards were placed in the same category across all participants.

5. Challenge: Plan a card sort for a documentation site with 10 categories. Select 30 cards, recruit 15 participants, and describe how you would analyze the results.

FAQ

Mini Project

Conduct a card sort for a documentation section. Select 30 cards, recruit 5-10 participants, analyze the similarity matrix, identify ambiguous cards, and propose a taxonomy based on results.

What's Next

Now that you understand card sorting, learn Tree Testing to validate navigation labels. Then study Sitemaps.