research-qualitative-methods

name	research-qualitative-methods
description	Master qualitative research methods including interviews, ethnography, case studies, grounded theory, and thematic analysis

Qualitative Research Methods Skill

When to Use This Skill

Use this skill when you need to:

• Explore phenomena in depth
• Understand lived experiences and meanings
• Generate theory from data
• Study context and complexity
• Investigate "how" and "why" questions
• Capture participant perspectives
• Analyze textual or visual data
• Conduct case studies or ethnographic research

Core Qualitative Approaches

1. In-Depth Interviews

Purpose: Explore individual perspectives and experiences

Interview Protocol Template:

from dataclasses import dataclass
from typing import List, Optional
from datetime import datetime

@dataclass
class InterviewProtocol:
    """Structure for interview guide"""
    research_question: str
    introduction: str
    opening_questions: List[str]
    main_questions: List[str]
    probes: dict  # question -> list of probes
    closing_questions: List[str]
    estimated_duration: int  # minutes

    def generate_guide(self):
        """Generate formatted interview guide"""
        guide = f"""
# Interview Guide

## Research Question
{self.research_question}

## Introduction ({estimated_duration} minutes)
{self.introduction}

## Opening Questions (5-10 minutes)
"""
        for i, q in enumerate(self.opening_questions, 1):
            guide += f"{i}. {q}\n"

        guide += "\n## Main Questions (30-40 minutes)\n"
        for i, q in enumerate(self.main_questions, 1):
            guide += f"{i}. {q}\n"
            if q in self.probes:
                for probe in self.probes[q]:
                    guide += f"   - Probe: {probe}\n"

        guide += "\n## Closing Questions (5-10 minutes)\n"
        for i, q in enumerate(self.closing_questions, 1):
            guide += f"{i}. {q}\n"

        return guide

# Example protocol
protocol = InterviewProtocol(
    research_question="How do remote workers maintain work-life balance?",
    introduction="""
Thank you for participating. This interview will take about 60 minutes.
I'm interested in understanding your experiences with remote work.
There are no right or wrong answers. Everything you share will be kept
confidential. Do you have any questions before we begin?
""",
    opening_questions=[
        "Can you tell me about your current remote work situation?",
        "How long have you been working remotely?"
    ],
    main_questions=[
        "Walk me through a typical workday. What does it look like?",
        "How do you separate work time from personal time?",
        "What challenges have you faced with work-life balance?",
        "What strategies have you found helpful?"
    ],
    probes={
        "Walk me through a typical workday. What does it look like?": [
            "What time do you typically start?",
            "How do you structure your day?",
            "Where do you work from?"
        ],
        "What challenges have you faced with work-life balance?": [
            "Can you give me a specific example?",
            "How did that make you feel?",
            "What did you do about it?"
        ]
    },
    closing_questions=[
        "Is there anything else you'd like to share?",
        "What advice would you give to new remote workers?"
    ],
    estimated_duration=60
)

print(protocol.generate_guide())

2. Thematic Analysis

Purpose: Identify patterns and themes in qualitative data

Six-Phase Process:

import pandas as pd
from collections import defaultdict
from typing import List, Dict, Set

class ThematicAnalysis:
    """Conduct rigorous thematic analysis"""

    def __init__(self):
        self.transcripts = {}
        self.codes = defaultdict(list)
        self.themes = {}
        self.codebook = {}

    # Phase 1: Familiarization
    def add_transcript(self, participant_id: str, text: str):
        """Add transcript and initial notes"""
        self.transcripts[participant_id] = {
            'text': text,
            'initial_notes': []
        }

    def add_initial_note(self, participant_id: str, note: str):
        """Record initial observations"""
        self.transcripts[participant_id]['initial_notes'].append(note)

    # Phase 2: Generate initial codes
    def code_segment(self, participant_id: str, segment: str,
                    code: str, line_numbers: tuple):
        
        .codes[code].append({
            : participant_id,
            : segment,
            : line_numbers
        })

     ():
        
         {code: (instances)
                 code, instances  .codes.items()}

    
     ():
        
        .themes[theme_name] = {
            : codes,
            : description,
            : []
        }

     ():
        
        .themes[theme_name][].append({
            : subtheme_name,
            : codes
        })

    
     ():
        
        excerpts = []
        theme = .themes[theme_name]

         code  theme[]:
             code  .codes:
                excerpts.extend(.codes[code])

         excerpts

     ():
        
        excerpts = .get_theme_excerpts(theme_name)

        report = {
            : theme_name,
            : (excerpts),
            : ((e[]  e  excerpts)),
            : .themes[theme_name][],
            : excerpts[:]  
        }

         report

    
     ():
        
        .themes[theme_name][] = definition
        .themes[theme_name][] = essence

    
     ():
        
        codebook = []

         theme_name, theme_data  .themes.items():
            entry = {
                : theme_name,
                : theme_data.get(, ),
                : .join(theme_data[]),
                : (.get_theme_excerpts(theme_name))
            }
            codebook.append(entry)

         pd.DataFrame(codebook)

     ():
        
        report = 
        report += 
        report += 
        report += 

         theme_name, theme_data  .themes.items():
            report += 
            report += 
            report += 
            report += 

            excerpts = .get_theme_excerpts(theme_name)
            report += 
            report += 

            
            report += 
             i, excerpt  (excerpts[:], ):
                report += 
                report += 

            
             theme_data.get():
                report += 
                 subtheme  theme_data[]:
                    report += 
                    report += 
                report += 

         report


analysis = ThematicAnalysis()


analysis.add_transcript(, )
analysis.add_initial_note(, )


analysis.code_segment(,
    ,
    ,
    (, ))
analysis.code_segment(,
    ,
    ,
    (, ))


analysis.create_theme(
    ,
    codes=[, , ],
    description=
)

analysis.define_theme(
    ,
    definition=,
    essence=
)


(analysis.generate_theme_report())

3. Grounded Theory

Purpose: Generate theory from data inductively

Coding Approach:

from dataclasses import dataclass
from typing import List, Optional, Dict
from enum import Enum

class CodingLevel(Enum):
    OPEN = "open"
    AXIAL = "axial"
    SELECTIVE = "selective"

@dataclass
class GroundedTheoryCode:
    """Represent a grounded theory code"""
    code: str
    level: CodingLevel
    definition: str
    properties: List[str]
    dimensions: Dict[str, tuple]  # property -> (min, max) dimensions
    memos: List[str]
    examples: List[str]

class GroundedTheoryAnalysis:
    """Conduct grounded theory analysis"""

    def __init__(self):
        self.codes = {}
        self.categories = {}
        self.core_category = None
        self.theoretical_memos = []

    def open_coding(self, code_name: str, definition: str):
        """Initial open coding"""
        .codes[code_name] = GroundedTheoryCode(
            code=code_name,
            level=CodingLevel.OPEN,
            definition=definition,
            properties=[],
            dimensions={},
            memos=[],
            examples=[]
        )

     ():
        
        .categories[category_name] = {
            : codes,
            : conditions,  
            : actions,  
            : consequences,  
            : CodingLevel.AXIAL
        }

     ():
        
        .core_category = {
            : core_category,
            : storyline,
            : CodingLevel.SELECTIVE
        }

     ():
        
         code  code  .codes:
            .codes[code].memos.append(memo)
        :
            .theoretical_memos.append(memo)

     ():
        
        c1 = .codes.get(code1)
        c2 = .codes.get(code2)

          c1   c2:
             

        comparison = 
        comparison += 
        comparison += 
        comparison += 
        comparison += 
        comparison += 

         comparison

     ():
        
        guide = 
        guide += 
         .core_category:
            guide += 
            guide += 

        guide += 
        guide += 
        guide += 
        guide += 

        guide += 
        guide += 
        guide += 
        guide += 

         guide


gt = GroundedTheoryAnalysis()


gt.open_coding(,
    )
gt.open_coding(,
    )


gt.axial_coding(
    category_name=,
    codes=[, , ],
    conditions=[, , ],
    actions=[, , ],
    consequences=[, , ]
)


gt.selective_coding(
    core_category=,
    storyline=
              
              
)


gt.add_memo(
            ,
            code=)

4. Case Study Research

Purpose: In-depth examination of bounded system

Case Study Protocol:

from dataclasses import dataclass
from typing import List, Dict
from enum import Enum

class CaseType(Enum):
    SINGLE = "single"
    MULTIPLE = "multiple"
    EMBEDDED = "embedded"

class DataSource(Enum):
    INTERVIEW = "interview"
    OBSERVATION = "observation"
    DOCUMENT = "document"
    ARTIFACT = "artifact"
    ARCHIVAL = "archival"

@dataclass
class CaseStudyDesign:
    """Define case study parameters"""
    case_type: CaseType
    research_questions: List[str]
    propositions: List[str]
    units_of_analysis: str
    case_selection_logic: str
    data_sources: List[DataSource]

    def generate_protocol(self):
        """Generate case study protocol"""
        protocol = f"""
# Case Study Protocol

## Overview
Type: {self.case_type.value}
Unit of Analysis: {self.units_of_analysis}

## Research Questions
"""
        for i, q in enumerate(self.research_questions, 1):
            protocol += f". \n"

        protocol += 
         i, p  (.propositions, ):
            protocol += 

        protocol += 

        protocol += 
         source  .data_sources:
            protocol += 

         protocol

 :
    

     ():
        .evidence = defaultdict()
        .chain_of_evidence = []

     ():
        
        evidence_id = 
        .evidence[source].append({
            : evidence_id,
            : content,
            : date,
            : related_rq
        })
         evidence_id

     ():
        
        .chain_of_evidence.append({
            : finding,
            : evidence_ids
        })

     ():
        
        rows = []
         source, items  .evidence.items():
             item  items:
                rows.append({
                    : item[],
                    : source.value,
                    : item[],
                    : item[]
                })
         pd.DataFrame(rows)


design = CaseStudyDesign(
    case_type=CaseType.SINGLE,
    research_questions=[
        ,
        
    ],
    propositions=[
        ,
        
    ],
    units_of_analysis=,
    case_selection_logic=,
    data_sources=[DataSource.INTERVIEW, DataSource.DOCUMENT, DataSource.OBSERVATION]
)

(design.generate_protocol())

Qualitative Patterns

Rigorous Qualitative Research

✓ Reflexivity acknowledged
✓ Thick description provided
✓ Triangulation of data sources
✓ Member checking conducted
✓ Negative cases sought
✓ Audit trail maintained
✓ Saturation documented
✓ Context richly described

Weak Qualitative Research

✗ Researcher bias unacknowledged
✗ Thin description (anecdotes only)
✗ Single data source
✗ Cherry-picking quotes
✗ Ignoring disconfirming evidence
✗ Unclear analysis process
✗ Sample too small for claims
✗ Decontextualized findings

Best Practices

1. Data Collection

• Build rapport before deep questions
• Use open-ended questions
• Practice active listening
• Follow up on interesting points
• Record with permission
• Take field notes immediately after
• Continue until saturation

2. Analysis

• Start analysis during collection
• Code systematically
• Write analytic memos frequently
• Check codes with second coder
• Seek negative cases
• Connect to existing theory
• Ground findings in data

3. Quality Criteria

• Credibility: Prolonged engagement, triangulation, member checks
• Transferability: Thick description, context detail
• Dependability: Audit trail, clear methods
• Confirmability: Reflexivity, raw data available

Related Skills

• research-design: Planning qualitative studies
• data-collection: Interview and observation protocols
• data-analysis: Qualitative data analysis software
• research-synthesis: Synthesizing qualitative findings
• research-writing: Writing qualitative reports

Quick Reference

Sample Sizes

Interviews:        5-25 for phenomenology
                   20-30 for grounded theory
                   1-3 for case study
Focus Groups:      3-5 groups of 6-10 participants
Ethnography:       Extended engagement (months to years)

When to Stop Collecting Data

✓ Theoretical saturation reached
✓ No new themes emerging
✓ Negative cases explored
✓ All research questions addressed
✓ Rich description achieved