Little Boy's Tardis

Tardis gathers all AABW announcements into one dashboard, using AI to summarize and personalize updates for Builders and Guests, so everyone stays informed and never misses a deadline.

Comment

Inspiration

During large-scale hackathons and events, there is a massive communication gap between event organizers (Judges) and developers. Participants are constantly bombarded with chaotic announcements across fragmented channels like Discord and WhatsApp. Critical deadlines, rule changes, and urgent server alerts get lost in the noise. 

Our mission with Tardis is to bridge this gap. We wanted to build an asynchronous, event-driven architecture combined with state-of-the-art Large Language Models (LLMs) to transform that chaotic flood of notifications into structured, real-time, actionable intelligence.

What it does

Tardis acts as the ultimate command center for hackathon participants and judges.

  • Universal Ingestion: It captures raw payloads from Discord and WhatsApp webhooks in real time.
  • Smart Aggregation: Instead of processing every ping, it queues messages and intelligently aggregates them over set intervals.
  • AI Processing: Uses the Qwen-Turbo LLM to analyze the aggregated text, extract "Key Takeaways," merge duplicate meanings, and categorize the urgency (High/Medium/Low).
  • Live Dashboard: Broadcasts the final structured intelligence via WebSocket STOMP streaming straight to a responsive React dashboard.

How we built it

Our team (Little Boy's Tardis) divided the architecture into distinct, highly resilient components:

  • The Ingestion Pipeline (@an1dee): We built lightning-fast Spring Boot REST APIs with X-Webhook-Token security. The webhook receiver returns 200 OK in <50ms to prevent client timeouts.
  • The Message Broker (@teikv): We implemented RabbitMQ (exchanges and queues) to decouple ingestion from processing, ensuring background AI workers consume messages safely without dropping data.
  • The Frontend Client (@hahoangbach2005): We crafted a neo-brutalism dashboard using React, TSX and CSS. It features feed containers, real-time skeleton loaders, and a built-in webhook simulator.
  • The DevOps & Streaming (@h1eudayne): Everything is glued together using Docker Compose for seamless deployment. Real-time delivery is achieved using Spring WebSocket STOMP streaming, directly pushing processed data to the dashboard.

Tech Stack

Backend

Technology Purpose
Java / Spring Boot Core REST API framework; webhook ingestion endpoints with <50ms response times
Spring WebSocket (STOMP) Real-time bidirectional streaming of processed AI results to the frontend dashboard
RabbitMQ Message broker; decouples ingestion from AI processing via direct exchanges and routing keys
PostgreSQL Persistent storage for aggregated and AI-processed message intelligence

Frontend

Technology Purpose
React Component-based UI framework for the live intelligence dashboard
TypeScript (TSX) Type-safe component authoring
CSS Custom styling with feed containers, skeleton loaders, and a webhook simulator

AI & Intelligence

Technology Purpose
Qwen-Turbo LLM Analyzes aggregated messages, extracts key takeaways, deduplicates content, and categorizes urgency (High / Medium / Low)

DevOps & Infrastructure

Technology Purpose
Docker Compose Orchestrates all services (Spring Boot, RabbitMQ, PostgreSQL) into a single deployable stack
X-Webhook-Token Security layer for validating incoming webhook payloads

Integrations

Platform Integration Type
Discord Incoming webhook payload ingestion
WhatsApp Incoming webhook payload ingestion

Architecture Pipeline

Discord / WhatsApp Webhooks
        ↓
  Spring Boot REST API  (Ingestion — <50ms)
        ↓
     RabbitMQ           (Message Broker — Queuing & Decoupling)
        ↓
Spring Boot Worker      (Aggregation & Scheduling)
        ↓
    Qwen-Turbo LLM      (AI Processing — 3–5s)
        ↓
    PostgreSQL          (Persistent Storage)
        ↓
Spring WebSocket STOMP  (Real-time Streaming)
        ↓
   React Dashboard      (Live Intelligence Feed)

Challenges we ran into

  • Handling WebSocket Quirks: Ensuring true real-time synchronization was tough. We had to dive deep into custom STOMP frame parsing to robustly handle CRLF newline differences on Windows that were initially blocking live AI updates.
  • Asynchronous Resilience: Designing a system where webhooks, message queues, and AI APIs do not bottleneck each other required precise architecture planning.
  • AI Consistency: Prompting the Qwen-Turbo LLM to consistently return deduplicated, properly formatted bullet points without hallucinating information across multiple channels.

Accomplishments that we're proud of

  • Zero-Latency Feel: We successfully decoupled the heavy AI processing (which takes 3-5 seconds) from the user experience. The frontend instantly shows a skeleton loader when AI processing begins via WebSocket events.
  • Enterprise-Grade Pipeline: We successfully built a full microservice-style pipeline (Webhooks -> RabbitMQ -> Spring Boot Worker -> Qwen LLM -> Postgres -> WebSocket) entirely within the hackathon timeframe.
  • Stunning UI/UX: The dashboard is not just functional; it looks premium and solves a genuine pain point for developers.

What we learned

  • Message Brokering: We mastered RabbitMQ routing keys and direct exchanges to manage high-throughput event queues.
  • Event-Driven AI: We learned how to efficiently schedule and batch data before feeding it to an LLM, saving token costs and API rate limits.
  • Team Collaboration: Overlapping roles between Frontend, AI/Queue, Backend, and DevOps taught us the importance of defining clear API contracts and data structures early on.

What's next for Tardis

  • Automatic Calendar Invites: Parsing extracted deadlines (e.g., "Submit by 11:59 PM") and turning them into 1-click Google Calendar events.
  • Expanded Integrations: Adding native support for Slack, Microsoft Teams, and Telegram webhooks.
  • Multi-Language Support: Translating Judge announcements into the participant's native language automatically via LLM. Add the tech stack of the project into this, then create a MD file

Built With

Share this project:

Updates