Skip to main content

​
Text Responses

Text responses allow reviewers to provide free-form written feedback, making them perfect for scenarios requiring detailed explanations, qualitative assessments, or open-ended input that can’t be captured through structured options.

​
When to Use Text Responses

Text responses are ideal for:

Content Review Feedback

Detailed feedback on articles, blog posts, or creative content where specific suggestions and explanations are valuable.

Quality Assessments

Explanations of why something passed or failed review, with specific recommendations for improvement.

Issue Reporting

Describing problems, bugs, or policy violations where context and detail are crucial for understanding.

Expert Analysis

Professional opinions, technical assessments, or domain expert evaluations requiring nuanced explanations.

​
Configuration Options

Text responses support several configuration parameters to control input validation and user experience:

​
Required Parameters

​
max_length
integer
required
Maximum number of characters allowed (1-5000)

​
Optional Parameters

​
placeholder
string
Placeholder text shown in the input field to guide reviewers
​
min_length
integer
default:"0"
Minimum number of characters required for the response
​
required
boolean
default:"false"
Whether the response is mandatory or can be left empty

​
Implementation Examples

​
Basic Text Response

Simple text feedback with basic validation: 
request_data = {
    "processing_type": "time-sensitive",
    "type": "markdown",
    "priority": "medium",
    "request_text": "Please review this blog post and provide feedback on accuracy, tone, and readability.",
    "response_type": "text",
    "response_config": {
        "max_length": 1000,
        "placeholder": "Provide your detailed feedback here...",
        "required": True
    },
    "default_response": "No feedback provided within the review period",
    "timeout_seconds": 3600,
    "platform": "api"
}

​
Advanced Text Response

Text response with length requirements and structured guidance: 
# Content editing request with detailed requirements
request_data = {
    "processing_type": "deferred",
    "type": "markdown",
    "priority": "low",
    "request_text": """
Please edit this article draft and provide improvement suggestions:

# Article Title: "10 Ways to Improve Your Productivity"

Content here would be the actual article...

Please focus on:
1. Grammar and spelling corrections
2. Flow and readability improvements  
3. Factual accuracy
4. Engagement and tone
""",
    "response_type": "text",
    "response_config": {
        "placeholder": "Provide specific editing suggestions with line references where possible. Format: '1. Grammar: Fix X in paragraph 2. 2. Flow: Restructure Y section...'",
        "min_length": 100,
        "max_length": 2000,
        "required": True
    },
    "default_response": "Editorial review not completed within deadline. Recommend postponing publication pending review.",
    "timeout_seconds": 86400,  # 24 hours
    "platform": "api"
}

​
Response Format

When a reviewer submits a text response, you’ll receive: 
{
  "response_data": "The article is well-structured and informative. Grammar is mostly correct with a few minor issues: 'it's' should be 'its' in paragraph 3, and there's a comma splice in the conclusion. The tone is engaging and appropriate for the target audience. I'd recommend adding one more concrete example in section 4 to strengthen the argument. Overall, this is ready for publication with those minor corrections."
}

​
Use Case Examples

​
1. Content Editorial Review

  • Configuration
  • Sample Response
  • Processing
editorial_config = {
    "response_type": "text",
    "response_config": {
        "placeholder": "Provide editorial feedback covering grammar, style, accuracy, and engagement. Include specific suggestions for improvement.",
        "min_length": 50,
        "max_length": 1200,
        "required": True
    },
    "default_response": "Editorial review incomplete - recommend additional review before publication"
}

​
2. Bug Report Verification

  • Configuration
  • Sample Response
  • Processing
bug_verification_config = {
    "response_type": "text", 
    "response_config": {
        "placeholder": "Describe steps taken to reproduce the bug, environment details, and whether you confirmed the issue. Include severity assessment.",
        "min_length": 75,
        "max_length": 800,
        "required": True
    },
    "default_response": "Bug verification not completed within SLA timeframe"
}

​
3. Expert Consultation

  • Configuration
  • Sample Response
  • Processing
expert_consultation_config = {
    "response_type": "text",
    "response_config": {
        "placeholder": "Provide your expert analysis including key insights, recommendations, risk assessment, and suggested next steps. Include confidence level in your assessment.",
        "min_length": 200,
        "max_length": 3000,
        "required": True
    },
    "default_response": "Expert consultation not completed within consultation period"
}

​
Validation and Error Handling

​
Client-Side Validation

The mobile app automatically validates text responses:
  • Length checking: Prevents submission if outside min/max bounds
  • Required validation: Blocks empty submissions when required=true
  • Character counting: Shows real-time character count to reviewers
  • Whitespace handling: Trims leading/trailing whitespace before validation

​
Server-Side Validation

Your application should also validate responses: 
def validate_text_response(response_data, response_config):
    """Validate text response against configuration"""
    
    if not isinstance(response_data, str):
        return False, "Response must be text"
    
    # Check required
    if response_config.get("required", False) and not response_data.strip():
        return False, "Response is required"
    
    # Check length bounds
    text_length = len(response_data.strip())
    min_length = response_config.get("min_length", 0)
    max_length = response_config.get("max_length", 5000)
    
    if text_length < min_length:
        return False, f"Response too short (minimum {min_length} characters)"
    
    if text_length > max_length:
        return False, f"Response too long (maximum {max_length} characters)"
    
    return True, "Valid"

# Usage
is_valid, error_message = validate_text_response(
    response_data="This is the reviewer's feedback...",
    response_config={
        "min_length": 20,
        "max_length": 500,
        "required": True
    }
)

​
Best Practices

​
Configuration Best Practices

  • Short feedback: 50-300 characters for quick comments
  • Detailed reviews: 200-1500 characters for thorough analysis
  • Expert consultations: 500-3000 characters for comprehensive assessments
  • Avoid extremes: too short limits valuable feedback, too long reduces completion rates
  • Use descriptive placeholders that explain what you’re looking for
  • Include examples of good feedback in the request_text
  • Specify focus areas or structured format when helpful
  • Guide reviewers on the level of detail expected
  • Time-sensitive requests: shorter responses, clear urgency indicators
  • Expert reviews: longer limits, domain-specific guidance
  • Quality checks: structured feedback requests with specific criteria
  • Editorial reviews: formatting suggestions and style guide references

​
Processing Best Practices

# Extract actionable insights from text feedback
def analyze_text_feedback(feedback_text):
    insights = {
        "sentiment": analyze_sentiment(feedback_text),
        "action_items": extract_action_items(feedback_text), 
        "mentioned_issues": identify_issues(feedback_text),
        "confidence_indicators": find_confidence_signals(feedback_text)
    }
    return insights

# Combine multiple text responses for consensus
def aggregate_text_responses(responses):
    common_themes = identify_common_themes(responses)
    conflicting_opinions = find_disagreements(responses)
    
    return {
        "consensus_points": common_themes,
        "areas_of_disagreement": conflicting_opinions,
        "recommendation": generate_final_recommendation(responses)
    }

# Score text response quality and usefulness
def score_response_quality(response_text, criteria):
    scores = {}
    
    # Length appropriateness
    scores["length"] = evaluate_response_length(response_text)
    
    # Specificity and actionability  
    scores["specificity"] = count_specific_examples(response_text)
    
    # Coverage of requested criteria
    scores["coverage"] = check_criteria_coverage(response_text, criteria)
    
    return calculate_overall_score(scores)

​
Next Steps

Single Select Responses

Learn about structured decision-making with predefined options

Multi Select Responses

Combine text feedback with categorical selections

Response Processing

Understand how to handle and analyze different response types

Mobile App Experience

See how reviewers interact with text responses on mobile
⌘I