Skip to main content

​
Single Select Responses

Single select responses allow reviewers to choose exactly one option from a predefined list, making them perfect for clear decision workflows, approval processes, and structured categorization where mutual exclusivity is important.

​
When to Use Single Select

Single select responses are ideal for:

Approval Workflows

Simple approve/reject decisions, or approval with conditions like “Approve”, “Reject”, “Needs Changes”

Content Classification

Categorizing content into mutually exclusive categories like content type, priority level, or department

Quality Assessment

Rating content quality with discrete levels like “Excellent”, “Good”, “Fair”, “Poor”

Status Assignment

Setting request status, priority levels, or routing decisions where only one choice makes sense

​
Configuration Options

Single select responses require an options array and support visual customization:

​
Required Parameters

​
options
array
required
Array of SelectOption objects (1-20 options maximum)

​
Optional Parameters

​
required
boolean
default:"false"
Whether a selection is mandatory for completion

​
Implementation Examples

​
Basic Approval Workflow

Simple approve/reject decision with visual indicators: 
request_data = {
    "processing_type": "time-sensitive",
    "type": "markdown",
    "priority": "high", 
    "request_text": "Please review this user comment for community guideline compliance:\n\n'This product is amazing! I've been using it for 3 months and it completely changed my workflow. Highly recommend to anyone looking to improve productivity!'",
    "response_type": "single_select",
    "response_config": {
        "options": [
            {
                "value": "approve",
                "label": "✅ Approve Content"
            },
            {
                "value": "reject",
                "label": "❌ Reject Content"
            },
            {
                "value": "escalate", 
                "label": "🚨 Escalate for Review"
            }
        ],
        "required": True
    },
    "default_response": "reject",
    "timeout_seconds": 1800,
    "platform": "api"
}

​
Content Classification

Categorizing content into specific types: 
# Content categorization for routing
request_data = {
    "processing_type": "deferred",
    "type": "markdown", 
    "priority": "medium",
    "request_text": "Please categorize this customer inquiry:\n\n'Hi, I'm having trouble with my recent order #12345. The item was supposed to arrive yesterday but I haven't received it yet. Can you help track it down?'",
    "response_type": "single_select",
    "response_config": {
        "options": [
            {
                "value": "shipping_inquiry",
                "label": "📦 Shipping & Delivery"
            },
            {
                "value": "product_support",
                "label": "🛠️ Product Support"
            },
            {
                "value": "billing_payment", 
                "label": "💳 Billing & Payment"
            },
            {
                "value": "returns_exchanges",
                "label": "🔄 Returns & Exchanges"
            },
            {
                "value": "general_inquiry",
                "label": "📞 General Inquiry"
            }
        ],
        "required": True
    },
    "default_response": "general_inquiry",
    "timeout_seconds": 7200,
    "platform": "api"
}

​
Quality Assessment

Rating content quality with discrete levels: 
# Content quality evaluation
request_data = {
    "processing_type": "time-sensitive",
    "type": "markdown",
    "priority": "medium",
    "request_text": "Please evaluate the quality of this AI-generated article:\n\n[Article content would be included here...]\n\nFocus on accuracy, readability, and usefulness for our target audience.",
    "response_type": "single_select", 
    "response_config": {
        "options": [
            {
                "value": "excellent",
                "label": "⭐ Excellent Quality"
            },
            {
                "value": "good",
                "label": "✨ Good Quality"
            },
            {
                "value": "fair",
                "label": "📝 Fair Quality"
            },
            {
                "value": "poor",
                "label": "❌ Poor Quality"
            },
            {
                "value": "unusable",
                "label": "🚫 Unusable"
            }
        ],
        "required": True
    },
    "default_response": "fair",
    "timeout_seconds": 3600,
    "platform": "api"
}

​
Response Format

When a reviewer selects an option, you’ll receive both the internal value and the display label: 
{
  "response_data": {
    "selected_value": "approve",
    "selected_label": "✅ Approve Content"
  }
}

​
Use Case Examples

​
1. Content Moderation

  • Configuration
  • Processing Logic
moderation_config = {
    "response_type": "single_select",
    "response_config": {
        "options": [
            {
                "value": "approve",
                "label": "✅ Approve"
            },
            {
                "value": "approve_with_warning",
                "label": "⚠️ Approve with Warning"
            },
            {
                "value": "reject_minor",
                "label": "❌ Reject - Minor Violation"
            },
            {
                "value": "reject_major",
                "label": "🚨 Reject - Major Violation"
            },
            {
                "value": "reject_ban",
                "label": "🛑 Reject - Ban User"
            }
        ],
        "required": True
    }
}

​
2. Support Ticket Routing

  • Configuration
  • Processing Logic
ticket_routing_config = {
    "response_type": "single_select",
    "response_config": {
        "options": [
            {
                "value": "technical_support",
                "label": "🔧 Technical Support"
            },
            {
                "value": "billing_support", 
                "label": "💰 Billing Support"
            },
            {
                "value": "customer_success",
                "label": "🤝 Customer Success"
            },
            {
                "value": "sales_inquiry",
                "label": "💼 Sales Inquiry"
            },
            {
                "value": "escalation",
                "label": "🚨 Executive Escalation"
            }
        ],
        "required": True
    }
}

​
3. Document Approval Workflow

  • Configuration
  • Processing Logic
document_approval_config = {
    "response_type": "single_select", 
    "response_config": {
        "options": [
            {
                "value": "approved",
                "label": "✅ Approved for Publication"
            },
            {
                "value": "approved_with_changes",
                "label": "📝 Approved with Minor Changes"
            },
            {
                "value": "needs_revision", 
                "label": "🔄 Needs Revision"
            },
            {
                "value": "needs_legal_review",
                "label": "⚖️ Needs Legal Review"
            },
            {
                "value": "rejected",
                "label": "❌ Rejected"
            }
        ],
        "required": True
    }
}

​
Validation and Error Handling

​
Automatic Validation

The mobile app automatically validates single select responses:
  • Option validation: Ensures selected value exists in the options array
  • Required validation: Prevents submission when required=true and no selection made
  • Single selection: Enforces exactly one choice (radio button behavior)

​
Processing Validation

Your application should validate received responses: 
def validate_single_select_response(response_data, response_config):
    """Validate single select response against configuration"""
    # Check response structure
    if not isinstance(response_data, dict):
        return False, "Response must be an object"
    if "selected_value" not in response_data:
        return False, "Missing selected_value field"
    # Validate selected value exists in options
    valid_values = [opt["value"] for opt in response_config["options"]]
    selected = response_data["selected_value"]
    if selected not in valid_values:
        return False, f"Invalid selection: {selected}"
    # Check required
    if response_config.get("required", False) and not selected:
        return False, "Selection is required"
    return True, "Valid"
# Usage
is_valid, error_message = validate_single_select_response(
    response_data={
        "selected_value": "approve",
        "selected_label": "✅ Approve Content"
    },
    response_config={
        "options": [...],
        "required": True
    }
)

​
Best Practices

​
Option Design

  • Use descriptive labels that clearly communicate the choice
  • Avoid ambiguous or similar-sounding options
  • Include emoji or icons for visual differentiation
  • Keep labels concise but informative (under 50 characters ideal)
  • Put most common/expected choices first
  • Order by severity (mild to severe) or progression (low to high)
  • Group related options together
  • Consider alphabetical ordering for long lists
  • Provide context for options that might be unclear
  • Explain consequences or next steps for each choice
  • Include examples when helpful
  • Keep descriptions brief but informative
  • Use green (#22c55e) for positive/approval actions
  • Use red (#ef4444) for negative/rejection actions
  • Use yellow/orange (#f59e0b) for warnings or caution
  • Use blue (#3b82f6) for neutral/informational options
  • Use purple (#8b5cf6) for escalation or special handling

​
Processing Best Practices

# Clean, maintainable processing logic
def process_single_select_decision(response_data, context):
    decision = response_data["selected_value"]
    handlers = {
        "approve": handle_approval,
        "reject": handle_rejection,
        "escalate": handle_escalation,
        "needs_revision": handle_revision_request
    }
    handler = handlers.get(decision)
    if handler:
        return handler(context)
    else:
        log_error(f"Unknown decision: {decision}")
        return handle_default_case(context)

# Track decisions for compliance and analysis
def log_decision(request_id, response_data, reviewer_info):
    decision_log = {
        "request_id": request_id,
        "decision": response_data["selected_value"],
        "decision_label": response_data["selected_label"], 
        "reviewer_id": reviewer_info["user_id"],
        "reviewer_name": reviewer_info["name"],
        "timestamp": datetime.utcnow().isoformat(),
        "response_time_seconds": reviewer_info.get("response_time")
    }
    store_decision_log(decision_log)
    update_analytics(decision_log)

# Analyze decision patterns
def analyze_decision_patterns(loop_id, time_period="30d"):
    decisions = get_decisions_for_period(loop_id, time_period)
    # Decision distribution
    decision_counts = Counter(d["decision"] for d in decisions)
    # Reviewer consistency
    reviewer_patterns = analyze_reviewer_consistency(decisions)
    # Response time analysis
    avg_response_time = calculate_average_response_time(decisions)
    return {
        "decision_distribution": dict(decision_counts),
        "reviewer_consistency": reviewer_patterns,
        "average_response_time": avg_response_time,
        "total_decisions": len(decisions)
    }

​
Common Patterns

​
Progressive Approval Workflow

# Multi-stage approval with escalation
approval_stages = {
    "initial_review": {
        "options": ["approve", "needs_changes", "escalate_to_senior"]
    },
    "senior_review": {
        "options": ["final_approval", "send_back_for_revision", "escalate_to_executive"] 
    },
    "executive_review": {
        "options": ["executive_approval", "reject_with_explanation"]
    }
}

​
Severity-Based Processing

# Handle different severity levels appropriately
severity_handling = {
    "low": {"priority": "normal", "sla_hours": 24},
    "medium": {"priority": "high", "sla_hours": 8}, 
    "high": {"priority": "urgent", "sla_hours": 2},
    "critical": {"priority": "immediate", "sla_hours": 1}
}

​
Next Steps

Multi Select Responses

Learn about selecting multiple options from predefined lists

Text Responses

Combine structured decisions with detailed feedback

Response Processing

Advanced patterns for handling different response types

Mobile Experience

See how single select responses work in the mobile app
⌘I