ModQueue-Hub

Real-time coordination tool for Reddit moderators featuring intelligent priority scoring, collision prevention, and one-click user context enrichment.

Comment

What Inspired Us

As active Reddit users, we've witnessed the invisible workload moderators carry. We noticed moderators often work in silos—multiple mods reviewing the same reported items, missing critical content buried under low-priority spam, and opening 5+ tabs just to understand a user's history. After researching moderation pain points, we found that the CHI 2026 study on Reddit modqueue usage confirmed our observations: coordination issues, incomplete information signals, and time-wasting collisions are the top frustrations.

We wanted to build a tool that would make moderators' lives genuinely easier—not just another automation bot, but an intelligent assistant that helps human moderators work smarter together.

What We Learned

This was our first time building on the Devvit platform, and we learned extensively about Reddit's moderation ecosystem. Key technical learnings included:

  • Real-time coordination patterns: Implementing presence tracking and claim systems using Redis with strategic TTL (time-to-live) values to balance freshness and performance.

  • Priority scoring algorithms: Designing a rule-based scoring system that weighs multiple factors (report count, user karma, account age, content type) to produce intuitive 1-5 priority ratings without machine learning overhead.

  • Reddit API optimization: Batching API calls, implementing smart caching strategies, and handling rate limits while keeping the user experience responsive.

  • Context enrichment patterns: Aggregating data from multiple Reddit API endpoints (user profile, recent activity, moderation log) into a single coherent view.

We also learned important lessons about product design—how to surface the most critical information without overwhelming the interface, and how to design for multi-user coordination where consistency is paramount.

How We Built It

Architecture: We built ModQueue Intelligence Hub as a full-stack Devvit application with a clear separation between backend services and frontend components.

*Backend *

  • PresenceService: Tracks active moderators using Redis keys with 60-second TTL, updating on every dashboard interaction to maintain real-time accuracy.

  • ScoringService: Implements our priority scoring algorithm that calculates scores based on weighted factors. Items with 10+ reports and new accounts score 5 (CRITICAL), while established users with single reports score 1-2 (MINIMAL/LOW).

  • ContextService: Aggregates user data from multiple Reddit API calls, caching results in Redis for 10 minutes to reduce API load while keeping information current.

  • CollisionService: Manages item claims using Redis locks with 5-minute TTL, preventing race conditions when multiple mods attempt to claim simultaneously.

  • ModQueueService: Orchestrates all services, fetching the modqueue from Reddit, enriching each item with priority scores and claim status, then returning a sorted, actionable queue to the frontend.

*Frontend *

  • Dashboard component: Main interface rendering queue items sorted by priority, with real-time updates via 30-second polling.

  • ModQueueCard component: Individual item cards displaying priority badges, claim status, and action buttons with clear visual hierarchy using color-coded priority indicators.

  • ContextPanel component: Modal interface showing enriched user information including karma breakdown, account age, recent activity, and moderation history.

  • ActiveModerators component: Real-time display of currently active mods, helping teams coordinate workload distribution.

Data Layer: We designed a Redis key-value schema optimized for the Devvit platform:

  • Presence keys (presence:{username}) with 60s TTL for active moderator tracking
  • Claim keys (claim:{itemId}) with 5-minute TTL for collision prevention
  • Priority cache (priority:{itemId}) with 2-minute TTL for fast score retrieval
  • Context cache (context:{userId}) with 10-minute TTL to reduce API calls

Integration: We used TypeScript throughout for type safety, established shared constants and types in a centralized location to prevent integration bugs, and implemented comprehensive error handling to gracefully degrade when services are unavailable.

Challenges I Faced

1. Real-time coordination without websockets: Devvit doesn't support websockets, so we couldn't have true real-time updates. We solved this by implementing a polling-based presence system with smart TTL values and optimistic UI updates for claim actions, making the experience feel real-time even with 30-second refresh intervals.

2. Designing an intuitive priority algorithm: We initially tried complex weighted formulas that produced confusing decimal scores. We learned that moderators think in buckets, not precise numbers. We redesigned to a clean 1-5 integer scale with clear labels (CRITICAL, HIGH, MEDIUM, LOW, MINIMAL) and human-readable reasoning ("HIGH PRIORITY: 8 reports, 5-day-old account").

3. Claim collision race conditions: When two mods clicked "Claim" simultaneously, we initially had race conditions. We solved this by implementing atomic operations in Redis—check-and-set logic that ensures only one mod can claim an item, with the second attempt receiving immediate feedback that the item is already claimed.

4. Reddit API rate limits: Fetching user context for every queue item was hitting rate limits. We implemented aggressive caching (10-minute TTL for user data) and batch processing to group API calls, reducing requests by 75% while keeping data fresh enough for moderation decisions.

5. Mobile responsiveness: Our initial dashboard had fixed-width layouts that broke on mobile. We refactored to responsive grid systems and tested extensively on narrow screens to ensure mods could use the app on their phones during high-traffic events.

6. Integration debugging: As a two-person team working on separate layers, we initially had integration issues where the frontend expected different data structures than the backend provided. We solved this by establishing a shared types file early and implementing comprehensive TypeScript interfaces, catching mismatches at compile time rather than runtime.

The most rewarding part was seeing everything come together—watching the collision prevention work across two browser windows, seeing priority scores correctly identify spam waves, and experiencing the satisfaction of having all user context available in one click instead of tab-juggling.

sorry for lengthy details

Built With

Share this project:

Updates