Dev.to WebDev πŸ›  Dev πŸ‘ 0 πŸ“– 5 min read

Engineering Kabloom Daily: Building a Viral Volcano Trivia Puzzle with Zero-Duplicate Rules and Sub-50ms Edge Delivery

Engineering Kabloom Daily: Building a Viral Volcano Trivia Puzzle with Zero-Duplicate Rules and Sub-50ms Edge Delivery Daily web puzzle games have entered a new renaissance. From Wordle and Connections to Waffle and Co

Engineering Kabloom Daily: Building a Viral Volcano Trivia Puzzle with Zero-Duplicate Rules and Sub-50ms Edge Delivery

Daily web puzzle games have entered a new renaissance. From Wordle and Connections to Waffle and Contexto, players love deterministic, bite-sized daily challenges that test vocabulary, speed, and lateral thinking.

Recently, we designed and shipped Kabloom Dailyβ€”a rapid-fire volcano trivia game where players race against a 25-second timer to scale 7 escalating trivia categories before the mountain erupts.

Here is the technical retrospective on how we engineered the game mechanics, solved the "zero-duplicate constraint", generated deterministic daily seeds across timezones, and achieved sub-50ms global TTFB using modern edge architecture.

1. The Core Game Mechanics & Ruleset

Unlike traditional trivia where questions are passive multiple-choice quizzes, Kabloom Daily operates as an active recall word-ladder:

  1. 7 Escalating Stages: You begin at the volcanic base and climb 7 tiers to reach the summit.
  2. 25-Second Global Countdown: Each stage gives you a ticking clock. Successful answers bank leftover time into bonus score multipliers.
  3. Strict No-Duplicate Rule: A word used in Stage 1 cannot be reused in any subsequent stage, even if it fits the clue! For instance, if Canada is entered for "Countries starting with C", it is locked out if a later prompt asks for "Countries bordering the USA".
  4. Deterministic Daily Challenge: Every player globally gets the exact same deck of 7 prompts each calendar day (resetting at 00:00 UTC), allowing fair comparison on daily leaderboards and social share cards.
  5. Free Unlimited Practice Mode: For casual training or streaming, players can switch to unlimited Kabloom practice mode with randomly shuffled category decks.

2. Solving the Zero-Duplicate Validation Problem

In naive web games, clue validation often makes a round-trip HTTP request to a backend API to verify whether an input string is valid for a category. However, in a fast-paced 25-second game, even 150ms of network latency feels sluggish and ruins the flow state.

To provide instant typing feedback, we opted for client-side zero-latency validation with embedded Trie structures and normalized Set lookups:

class TriviaEngine {
  constructor(dataset) {
    this.dataset = dataset; // Category map with normalized answers
    this.usedAnswers = new Set();
    this.score = 0;
    this.currentStage = 0;
  }

  normalize(str) {
    return str.trim().toLowerCase().replace(/[^a-z0-9]/g, '');
  }

  validateSubmission(categoryKey, rawInput) {
    const input = this.normalize(rawInput);
    if (!input) return { valid: false, error: 'EMPTY_INPUT' };

    // 1. Check if word has already been claimed in a previous stage
    if (this.usedAnswers.has(input)) {
      return { 
        valid: false, 
        error: 'DUPLICATE_ANSWER', 
        message: 'Already used in a previous round! Think of another!' 
      };
    }

    // 2. Validate against category dictionary
    const categoryDict = this.dataset[categoryKey];
    if (!categoryDict || !categoryDict.has(input)) {
      return { 
        valid: false, 
        error: 'INVALID_ANSWER', 
        message: 'Not in our recognized category dictionary.' 
      };
    }

    // 3. Commit word to locked state
    this.usedAnswers.add(input);
    return { valid: true, canonicalName: categoryDict.get(input) };
  }
}

By storing verified answer aliases (e.g., mapping "usa", "u.s.a.", "united states", and "america" to the canonical entity) inside in-memory lookup maps, input validation happens in under 0.5 milliseconds.

3. Deterministic Daily Seeding via Linear Congruential PRNG

A classic pitfall of daily browser games is timezone desynchronization. If day calculation relies on local machine time, a player in Tokyo plays tomorrow's puzzle while a player in California plays yesterday's.

We solved this by anchoring all daily rotations to the Unix timestamp normalized to UTC midnight:

function getUtcDayIndex(): number {
  const now = new Date();
  const utcMidnight = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
  // Epoch anchor: 2026-11-20
  const epochAnchor = Date.UTC(2026, 10, 20);
  return Math.floor((utcMidnight - epochAnchor) / 86400000);
}

// Deterministic Mulberry32 PRNG for reproducible daily decks
function mulberry32(seed: number) {
  return function() {
    let t = seed += 0x6D2B79F5;
    t = Math.imul(t ^ (t >>> 15), t | 1);
    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  }
}

export function generateDailyDeck(allCategories: Category[]): Category[] {
  const dayIndex = getUtcDayIndex();
  const rng = mulberry32(dayIndex * 7919 + 1337);

  // Deterministic Fisher-Yates shuffle
  const pool = [...allCategories];
  for (let i = pool.length - 1; i > 0; i--) {
    const j = Math.floor(rng() * (i + 1));
    [pool[i], pool[j]] = [pool[j], pool[i]];
  }
  return pool.slice(0, 7);
}

Every morning at 00:00 UTC, the seed automatically increments by 1, serving a brand-new 7-tier challenge globally with zero database queries. If you ever miss a day or want to study previous puzzles, you can inspect the daily answers and clue archive.

4. UI/UX: Mobile-First Responsive Input Architecture

During our initial playtests, players reported difficulty typing answers on mobile devices: virtual keyboards covered the input form, and narrow horizontal inputs truncated long words.

To address this, we refactored the UI with three design principles:

  • Dedicated Full-Width Input Row: The typing box occupies 100% width on its own dedicated flex line, styled with a high-contrast glowing volcanic accent border.
  • Viewport-Aware Floating Dock: The action buttons (Submit, Hint, Skip) are sticky-docked below the input, preventing Android/iOS virtual keyboards from occluding the interactive zone.
  • Micro-Haptics and Shake Feedback: Invalid entries trigger a subtle CSS shake animation, giving immediate tactile confirmation without disrupting typing rhythm.

For strategic tips on how to manage your time and prioritize rare words, check out our in-depth volcano summit strategy guide.

5. Global Edge Delivery: Sub-50ms Across All Continents

Instead of hosting the game behind an expensive node cluster, we deployed the entire static asset bundle and game engine to Cloudflare's global edge network.

  • HTML & Theme Assets: Pre-rendered at build time and cached with aggressive Cache-Control headers.
  • Sub-50ms TTFB: Served directly from Cloudflare Edge POPs in 330+ cities worldwide.
  • Zero Ads & Zero Tracking: Uncluttered, lightweight, and blazing fast.

Conclusion & Play Online

Building Kabloom Daily proved that you don't need heavy game engines or megabytes of assets to create an addictive, viral web experience. A crisp loop, thoughtful constraint design (no repeated answers!), and clean edge architecture make for a memorable daily ritual.

Have you built a daily web game? What algorithms do you use for seed generation and category balancing? Let's discuss in the comments below!

πŸ“° Read the original article on Dev.to WebDev

Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes β€” full credit and traffic to the original publisher.