FastAPI-based question collection endpoint

Implement remote all-hands question collection tools using GitHub Issues, custom APIs, or Slack Block Kit that enable anonymous submissions, community upvoting, and duplicate question merging. Open collection 48 hours before meetings to accommodate all time zones, and allow at least 24 hours for leaders to prepare answers. Measure success through submission rates (20-40% participation), answer quality surveys, and time-to-answer metrics. Anonymous submission removes barriers for sensitive questions while upvoting surfaces genuine concerns rather than leadership assumptions.

Why Question Collection Matters for Remote All Hands

In distributed organizations, synchronous communication is expensive. When your team spans San Francisco, London, and Tokyo, finding a meeting time that works for everyone often means someone joins at 7 AM or 10 PM. Question collection tools transform these rare synchronous sessions from status updates into genuine two-way conversations.

The primary benefits include increased participation from introverted team members, time-bound responses that keep meetings focused, asynchronous preparation that leads to better answers, and documentation of common questions for future reference.

Core Features of an Effective Question Collection System

Before implementing a solution, define the requirements your tool must satisfy. An effective question collection system needs anonymous submission options to encourage honest feedback, threaded discussions for clarifying questions, upvoting mechanisms to surface community priorities, time-boxed collection windows aligned with meeting schedules, and integration with your existing communication platforms.

Implementation Approaches

Approach 1: Custom GitHub Issues Integration

For engineering teams already comfortable with GitHub, using Issues creates a low-friction workflow:

// GitHub Issue-based question collector
const { Octokit } = require('@octokit/rest');

async function createQuestionIssue(org, repo, questionData) {
  const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });

  const body = `
## Question Category
${questionData.category}

## Question
${questionData.text}

## Asked by
${questionData.anonymous ? 'Anonymous' : questionData.author}

## Priority (community voting below)
⬆️ React with thumbs up to prioritize
  `;

  const issue = await octokit.issues.create({
    owner: org,
    repo: repo,
    title: `[All-Hands Q&A] ${questionData.category}: ${questionData.text.substring(0, 50)}`,
    body: body,
    labels: ['all-hands', 'question']
  });

  return issue.data.number;
}

This approach works well because it keeps all questions in version control, allows for code formatting in answers, and integrates with existing notification workflows. However, the GitHub interface isn’t always intuitive for non-technical stakeholders.

Approach 2: Dedicated API with Real-time Updates

For organizations needing more control, building a custom question collection API provides maximum flexibility:

# FastAPI-based question collection endpoint
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from datetime import datetime, timedelta
from typing import List, Optional

app = FastAPI()

class Question(BaseModel):
    id: Optional[str] = None
    text: str
    author: str
    anonymous: bool = False
    category: str = "general"
    created_at: datetime = None
    upvotes: int = 0

# In-memory store (replace with database in production)
questions_db: List[Question] = []

@app.post("/questions")
async def submit_question(question: Question):
    question.id = f"q_{len(questions_db) + 1}"
    question.created_at = datetime.utcnow()
    questions_db.append(question)
    return question

@app.get("/questions")
async def get_questions(status: str = "open"):
    """Get all questions, sorted by upvotes"""
    filtered = [q for q in questions_db if q.status == status]
    return sorted(filtered, key=lambda x: x.upvotes, reverse=True)

@app.post("/questions/{question_id}/upvote")
async def upvote_question(question_id: str):
    for q in questions_db:
        if q.id == question_id:
            q.upvotes += 1
            return q
    raise HTTPException(status_code=404, detail="Question not found")

This pattern supports real-time updates via WebSockets, provides full control over the data model, and enables custom analytics. Deploy this alongside a frontend that displays questions on a big screen during the actual meeting.

Approach 3: Integrating with Existing Tools

Many teams use Slack or Microsoft Teams as their primary communication platform. Building question collection directly into these platforms increases adoption:

// Slack Block Kit for question submission
const questionModal = {
  type: 'modal',
  title: { type: 'plain_text', text: 'Submit Your Question' },
  blocks: [
    {
      type: 'input',
      element: {
        type: 'static_select',
        action_id: 'category',
        placeholder: { type: 'plain_text', text: 'Select category' },
        options: [
          { text: { type: 'plain_text', text: 'Product' }, value: 'product' },
          { text: { type: 'plain_text', text: 'Engineering' }, value: 'engineering' },
          { text: { type: 'plain_text', text: 'Culture' }, value: 'culture' },
          { text: { type: 'plain_text', text: 'Operations' }, value: 'operations' }
        ]
      },
      label: { type: 'plain_text', text: 'Category' }
    },
    {
      type: 'input',
      element: {
        type: 'plain_text_input',
        action_id: 'question_text',
        multiline: true
      },
      label: { type: 'plain_text', text: 'Your Question' }
    },
    {
      type: 'input',
      element: {
        type: 'checkboxes',
        action_id: 'anonymous',
        options: [{ text: { type: 'plain_text', text: 'Submit anonymously' }, value: 'yes' }]
      },
      label: { type: 'plain_text', text: 'Privacy' }
    }
  ],
  submit: { type: 'plain_text', text: 'Submit Question' }
};

Best Practices for Question Collection Workflow

Timing significantly impacts the quality of questions collected. Opening the question collection window 48 hours before the meeting allows team members in later time zones to contribute when it’s convenient for them. A 24-hour reminder increases completion rates substantially.

Categorization helps organizers prepare relevant speakers. When questions are tagged with categories like product roadmap, engineering decisions, or company culture, you can assign appropriate subject matter experts to answer.

Upvoting should be available to all participants, not just leadership. This surfaces genuinely pressing concerns rather than what leadership assumes matters. In practice, the questions that receive the most community upvotes often differ from leadership expectations.

Anonymous submission removes barriers for sensitive questions. Team members may want to ask about layoffs, compensation, or management decisions without attribution. Honor this by making truly anonymous options available.

Handling Question Quality

Not all submitted questions are well-formed or appropriate for the meeting format. Implement a moderation layer that can merge duplicate questions, rephrase unclear questions with author permission, and defer off-topic questions to separate channels.

// Simple question moderation logic
function moderateQuestions(questions) {
  return questions.map(q => {
    // Merge similar questions
    const duplicates = questions.filter(other =>
      other.id !== q.id &&
      levenshteinDistance(q.text, other.text) < 10
    );

    if (duplicates.length > 0) {
      q.text += `\n\n(Similar questions merged: ${duplicates.map(d => d.id).join(', ')})`;
    }

    // Mark for clarification if too vague
    if (q.text.split(' ').length < 5) {
      q.needs_clarification = true;
    }

    return q;
  });
}

Measuring Success

Track these metrics to improve your question collection process over time:

Question volume indicates engagement levels. If submission rates decline over multiple meetings, investigate whether the process has become burdensome or if team sentiment has shifted.

Participation rate measures what percentage of eligible team members submitted questions. A healthy rate falls between 20-40% for regular meetings.

Answer quality can be measured through post-meeting surveys. Ask attendees whether their questions were answered satisfactorily.

Time-to-answer tracks how quickly questions get responses. Long gaps between submission and answer often indicate organizational bottlenecks.

Built by theluckystrike — More at zovo.one