Generating Reports and Insights

Advanced analysis techniques for extracting maximum value from your research data.

Overview

After conducting user interviews, Synthetic Users provides powerful tools to analyze responses, identify patterns, and generate professional reports. This guide covers the complete analysis workflow.

Prerequisites: Completed study with interview responses (First Study Guide)

Understanding the Analysis Pipeline

Research analysis follows this flow:

1. Raw Interviews → Individual user responses
2. Summaries → AI-generated insights and themes
3. Knowledge Graphs → Visual relationship mapping
4. Reports → Professional documents for stakeholders
5. Follow-up Analysis → Iterative deep-dives

Generating Summaries

Create a Study Summary

Summaries aggregate all interview responses and extract key insights:

# Python
from syntheticusers import ApiClient, Configuration, StudiesApi

configuration = Configuration(
    host="https://api.syntheticusers.com/api/v1",
    access_token="your-access-token"
)

with ApiClient(configuration) as api_client:
    studies_api = StudiesApi(api_client)
    
    summary = studies_api.generate_summary_v1(
        project_id="your-project-id",
        study_id="your-study-id",
        summary_create={
            "title": "Q1 2026 User Research Findings",
            "description": "Key insights from mobile app navigation study"
        }
    )
    
    summary_id = summary.id
    print(f"Summary generated: {summary_id}")

// TypeScript
import { createConfiguration, StudiesApi } from '@syntheticusers/sdk'

const config = createConfiguration({
  baseServer: 'https://api.syntheticusers.com',
  authMethods: {
    HTTPBearer: {
      tokenProvider: {
        getToken: () => 'your-access-token'
      }
    }
  }
})

const studiesApi = new StudiesApi(config)

const summary = await studiesApi.generateSummaryV1({
  projectId: 'your-project-id',
  studyId: 'your-study-id',
  summaryCreate: {
    title: 'Q1 2026 User Research Findings',
    description: 'Key insights from mobile app navigation study'
  }
})

const summaryId = summary.id
console.log(`Summary generated: ${summaryId}`)

Use generate_summary to create AI-powered summaries.

What Summaries Include

Generated summaries typically contain:

• Key Themes: Recurring patterns across interviews
• User Sentiment: Emotional responses and attitudes
• Pain Points: Challenges and frustrations users mentioned
• Opportunities: Ideas and suggestions from users
• Quotes: Representative user statements
• Recommendations: Actionable next steps based on insights

Retrieve Summary Content

# Python
from syntheticusers import SummariesApi

summaries_api = SummariesApi(api_client)

summary_details = summaries_api.get_summary_v1(
    project_id="your-project-id",
    summary_id=summary_id
)

print(summary_details.content)

Use get_summary to retrieve summary details.

Interactive Analysis with Follow-ups

Ask Questions About Your Summary

Use natural language to explore specific aspects:

# Python
response = summaries_api.summary_follow_up_v1(
    project_id="your-project-id",
    summary_id=summary_id,
    summary_follow_up_request={
        "message": "What were the most common pain points mentioned by users over 40?"
    }
)

print(response.answer)

// TypeScript
import { SummariesApi } from '@syntheticusers/sdk'

const summariesApi = new SummariesApi(config)

const response = await summariesApi.summaryFollowUpV1({
  projectId: 'your-project-id',
  summaryId: summaryId,
  summaryFollowUpRequest: {
    message: 'What were the most common pain points mentioned by users over 40?'
  }
})

console.log(response.answer)

Use summary_follow_up to query summaries.

Example Follow-up Questions

• "What percentage of users mentioned accessibility concerns?"
• "How did iOS users differ from Android users in their responses?"
• "What specific features did power users request most frequently?"
• "Were there any surprising insights that contradicted our assumptions?"
• "Which user segment showed the most enthusiasm for the proposed solution?"

Iterative Deep-Dives

Chain follow-up questions to explore themes:

# Python
# Start broad
q1 = summaries_api.summary_follow_up_v1(
    project_id=project_id,
    summary_id=summary_id,
    summary_follow_up_request={"message": "What were the top 3 themes?"}
)

# Dig deeper into one theme
q2 = summaries_api.summary_follow_up_v1(
    project_id=project_id,
    summary_id=summary_id,
    summary_follow_up_request={"message": "Tell me more about the navigation theme. What specific issues did users mention?"}
)

# Get actionable recommendations
q3 = summaries_api.summary_follow_up_v1(
    project_id=project_id,
    summary_id=summary_id,
    summary_follow_up_request={"message": "Based on the navigation issues, what are the top 3 changes we should prioritize?"}
)

Visualizing Insights with Knowledge Graphs

Generate Knowledge Graphs

Knowledge graphs visualize relationships between:

• Problems and Solutions
• User Needs and Features
• Pain Points and Opportunities
• Concepts and Themes

# Python
knowledge_graph = studies_api.generate_knowledge_graph_v1(
    project_id="your-project-id",
    study_id="your-study-id"
)

print("Knowledge graph generated successfully!")
print(f"Nodes: {len(knowledge_graph.nodes)}")
print(f"Edges: {len(knowledge_graph.edges)}")

// TypeScript
const knowledgeGraph = await studiesApi.generateKnowledgeGraphV1({
  projectId: 'your-project-id',
  studyId: 'your-study-id'
})

console.log('Knowledge graph generated successfully!')
console.log(`Nodes: ${knowledgeGraph.nodes.length}`)
console.log(`Edges: ${knowledgeGraph.edges.length}`)

Use generate_knowledge_graph to create visualizations.

Understanding Graph Structure

Knowledge graphs contain:

• Nodes: Entities (problems, solutions, concepts, insights)
• Edges: Relationships (causes, solves, relates_to, supports)
• Attributes: Metadata (importance, sentiment, frequency)

Use Cases for Knowledge Graphs

• Pattern Recognition: Identify which problems affect multiple solutions
• Impact Analysis: See which solutions address the most pain points
• Theme Clustering: Group related concepts visually
• Stakeholder Communication: Present complex findings intuitively

Creating Professional Reports

Standalone Reports

Create comprehensive documents that combine multiple data sources:

# Python
from syntheticusers import ReportsApi

reports_api = ReportsApi(api_client)

report = reports_api.create_report_v1(
    project_id="your-project-id",
    report_create={
        "title": "Q1 2026 Mobile App Research Report",
        "description": "Comprehensive findings from navigation study with actionable recommendations",
        "study_ids": ["study-1", "study-2"],  # Include multiple studies
        "summary_ids": ["summary-1", "summary-2"]  # Include multiple summaries
    }
)

report_id = report.id
print(f"Report created: {report_id}")

// TypeScript
import { ReportsApi } from '@syntheticusers/sdk'

const reportsApi = new ReportsApi(config)

const report = await reportsApi.createReportV1({
  projectId: 'your-project-id',
  reportCreate: {
    title: 'Q1 2026 Mobile App Research Report',
    description: 'Comprehensive findings from navigation study with actionable recommendations',
    studyIds: ['study-1', 'study-2'],  // Include multiple studies
    summaryIds: ['summary-1', 'summary-2']  // Include multiple summaries
  }
})

const reportId = report.id
console.log(`Report created: ${reportId}`)

Use create_report to create reports.

Generate Report Content

Build the complete report with sections:

# Python
full_report = reports_api.generate_full_report_v1(
    project_id="your-project-id",
    report_id=report_id
)

print("Full report generated!")
print(f"Sections: {len(full_report.sections)}")

Use generate_full_report to build report content.

Generate Table of Contents

Create structured navigation for long reports:

# Python
toc = reports_api.generate_toc_endpoint_v1(
    project_id="your-project-id",
    report_id=report_id
)

for section in toc.sections:
    print(f"{section.number}. {section.title}")

Use generate_toc_endpoint to create table of contents.

Retrieve Report Details

# Python
report_details = reports_api.get_report_v1(
    project_id="your-project-id",
    report_id=report_id
)

print(report_details.title)
print(report_details.content)

Use get_report to retrieve report details.

Exporting and Sharing

Export Summaries

Download summaries in multiple formats:

# Python
# Export as PDF
pdf_content = summaries_api.export_summary_v1(
    project_id="your-project-id",
    summary_id=summary_id,
    format="pdf"
)

with open("research-summary.pdf", "wb") as f:
    f.write(pdf_content)

# Export as plain text
text_content = summaries_api.export_summary_v1(
    project_id="your-project-id",
    summary_id=summary_id,
    format="txt"
)

with open("research-summary.txt", "w") as f:
    f.write(text_content.decode('utf-8'))

// TypeScript
// Export as PDF
const pdfContent = await summariesApi.exportSummaryV1({
  projectId: 'your-project-id',
  summaryId: summaryId,
  format: 'pdf'
})

await fs.promises.writeFile('research-summary.pdf', pdfContent)

// Export as plain text
const textContent = await summariesApi.exportSummaryV1({
  projectId: 'your-project-id',
  summaryId: summaryId,
  format: 'txt'
})

await fs.promises.writeFile('research-summary.txt', textContent)

Use export_summary to export summaries.

Download Study PDFs

Export complete studies with all interviews:

# Python
study_pdf = studies_api.get_study_pdf_v1(
    project_id="your-project-id",
    study_id="your-study-id"
)

with open("complete-study.pdf", "wb") as f:
    f.write(study_pdf)

print("Study PDF exported successfully!")

// TypeScript
const studyPdf = await studiesApi.getStudyPdfV1({
  projectId: 'your-project-id',
  studyId: 'your-study-id'
})

await fs.promises.writeFile('complete-study.pdf', studyPdf)
console.log('Study PDF exported successfully!')

Use get_study_pdf to download studies as PDFs.

Sharing Best Practices

• PDFs: Best for stakeholder presentations and archival
• Text: Easy to integrate into other documents or tools
• Knowledge Graphs: Share visual insights in meetings
• Report Links: Provide web access for collaborative review

Advanced Analysis Techniques

Comparing Multiple Studies

Analyze trends across multiple research initiatives:

# Python
# Create a meta-report combining multiple studies
meta_report = reports_api.create_report_v1(
    project_id="your-project-id",
    report_create={
        "title": "Q4 2025 - Q1 2026 Quarterly Insights",
        "description": "Trends and patterns across 4 months of user research",
        "study_ids": [
            "study-oct-2025",
            "study-nov-2025",
            "study-dec-2025",
            "study-jan-2026"
        ]
    }
)

# Ask comparative questions
comparison = summaries_api.summary_follow_up_v1(
    project_id="your-project-id",
    summary_id=meta_summary_id,
    summary_follow_up_request={
        "message": "How have user priorities changed from October to January?"
    }
)

Regenerating Analysis

Update summaries when you add new interview data:

# Python
# Run additional interviews
studies_api.interview_v1(
    project_id="your-project-id",
    study_id="your-study-id",
    interview_request={
        "message": "Follow-up question based on initial findings..."
    }
)

# Regenerate summary to include new data
updated_summary = studies_api.generate_summary_v1(
    project_id="your-project-id",
    study_id="your-study-id",
    summary_create={
        "title": "Updated Research Findings",
        "description": "Includes follow-up interview responses"
    }
)

Segment-Specific Analysis

Analyze subsets of your audience:

# Python
# Ask targeted follow-up questions
power_users = summaries_api.summary_follow_up_v1(
    project_id="your-project-id",
    summary_id=summary_id,
    summary_follow_up_request={
        "message": "Focus only on responses from users who identified as 'power users'. What were their unique concerns?"
    }
)

mobile_vs_desktop = summaries_api.summary_follow_up_v1(
    project_id="your-project-id",
    summary_id=summary_id,
    summary_follow_up_request={
        "message": "Compare the responses of mobile-first users vs desktop-first users. What differences stand out?"
    }
)

Monitoring Progress in Real-time

Stream Events

Track analysis generation as it happens:

# Python
from syntheticusers import ProjectsApi

projects_api = ProjectsApi(api_client)

# Stream events for real-time updates
events = projects_api.stream_events_v1(
    project_id="your-project-id",
    workspace_id="your-workspace-id"
)

for event in events:
    if event.type == "summary.generated":
        print(f"Summary complete: {event.data.summary_id}")
    elif event.type == "report.generated":
        print(f"Report complete: {event.data.report_id}")

Use stream_events for real-time monitoring.

Best Practices

When to Generate Summaries

• After all interviews complete: Wait for full dataset
• Before stakeholder meetings: Prepare insights in advance
• At research milestones: Capture progress at key points

Effective Follow-up Questions

• Start broad, then narrow: "What were the themes?" → "Tell me more about theme X"
• Compare segments: "How did group A differ from group B?"
• Quantify insights: "What percentage mentioned feature X?"
• Seek actionability: "What are the top 3 changes to prioritize?"

Report Structure

Include these sections for comprehensive reports:

1. Executive Summary: Key findings at a glance
2. Methodology: Study design and audience details
3. Key Insights: Main themes with supporting quotes
4. Recommendations: Prioritized action items
5. Appendix: Full interview transcripts and data

Export Timing

• Draft insights: Use text format for easy editing
• Internal reviews: Share web links for collaboration
• Final deliverables: Export PDFs for distribution

Troubleshooting

Empty or incomplete summaries?

• Ensure all interviews completed successfully
• Check that interview responses contain substantive content
• Try regenerating with a more specific description

Knowledge graph not displaying relationships?

• Verify that problems and solutions are linked to the study
• Ensure concepts are properly tagged
• Check that interview data contains entity references

Export failures?

• Verify summary generation completed successfully
• Check that you have the necessary permissions
• Try a different export format

Next Steps

• Core Concepts - Understanding the data model
• Conducting Your First Study - Complete workflow
• API Reference - Full endpoint documentation
• Python SDK - SDK documentation
• TypeScript SDK - SDK documentation