Detailed Component Design

1. Concurrent ID Generation (Avoiding Duplicates)

The Problem

plain

Copy

Server A: "Give me ID" → Database: "1000"
Server B: "Give me ID" → Database: "1000" ← SAME! 😱

Both servers get 1000 → both create shortCode = "g8" → COLLISION

Solutions

Table

ApproachHow It WorksProsCons
Database Lock	`SELECT FOR UPDATE`	Simple	Slow, bottlenecks at scale
UUID/GUID	Random 128-bit number	No coordination needed	Too long for short URLs
ID Blocks	Pre-allocate ranges	Fast, no conflicts	Slightly complex
Snowflake	Time-based distributed ID	No central DB, sortable	Needs NTP sync

Our Choice: ID Blocks (Best Balance)

plain

Copy

┌─────────────────────────────────────┐
│         ID Generator Service        │
│   (Knows: next available = 1,000,000) │
└─────────────────────────────────────┘
           ↓ Hands out blocks of 1000
    ┌─────────┐  ┌─────────┐  ┌─────────┐
    │ Server 1│  │ Server 2│  │ Server 3│
    │1M-1.001M│  │1.001M-  │  │1.002M-  │
    │         │  │1.002M   │  │1.003M   │
    └─────────┘  └─────────┘  └─────────┘

Implementation:

JavaScript

Copy

// ID Generator Service
class IDGenerator {
    constructor() {
        this.nextId = 1000000;  // Start here
        this.blockSize = 1000;
    }
    
    allocateBlock() {
        const start = this.nextId;
        this.nextId += this.blockSize;
        return { start, end: start + this.blockSize - 1 };
    }
}

// Each app server
class AppServer {
    constructor() {
        this.currentId = null;
        this.maxId = null;
    }
    
    async getNextId() {
        // Need more IDs?
        if (this.currentId >= this.maxId) {
            const block = await idGenerator.allocateBlock();
            this.currentId = block.start;
            this.maxId = block.end;
        }
        return this.currentId++;
    }
}

Result: Servers generate IDs locally, no database calls, guaranteed unique.

2. Preventing Predictable IDs

The Problem

Base62 sequential IDs: 1, 2, 3, 4... 10, 11... a, b, c...

Attack: bit.ly/100, bit.ly/101, bit.ly/102 → scrape all URLs!

Solutions

Table

ApproachHowResult
Start at offset	Begin at 1,000,000,000 instead of 1	`bit.ly/15FTGg8` not `bit.ly/1`
Bit scrambling	Shuffle bits with secret key	`1 → 9847321`, `2 → 1048293`
Random permutation	Feistel cipher on ID	Reversible, unpredictable
Crypto hash	`HMAC(id, secret)`	One-way, can't reverse

Our Choice: Bit Scrambling + Offset (Fast & Reversible)

JavaScript

Copy

const SECRET_KEY = 0x5DEECE66D; // Random seed

function scrambleId(id) {
    // Start at offset (prevent tiny codes)
    id += 1000000000;
    
    // XOR with secret (simple scrambling)
    id ^= SECRET_KEY;
    
    // Mix bits (multiply by odd number, mod 2^53)
    id = (id * 0xB) & 0x1FFFFFFFFFFFFF;
    
    return id;
}

function unscrambleId(scrambled) {
    // Reverse: find modular inverse of 0xB
    const inverse = 0x2E8C2D41; // Pre-calculated
    let id = (scrambled * inverse) & 0x1FFFFFFFFFFFFF;
    id ^= SECRET_KEY;
    id -= 1000000000;
    return id;
}

// Test:
console.log(toBase62(scrambleId(1)));   // "1aKz92" (not "1")
console.log(toBase62(scrambleId(2)));   // "3mNp45" (not "2")
console.log(toBase62(scrambleId(3)));   // "7xQr78" (not "3")

Properties:

Reversible (can decode short code back to ID)
Unpredictable (can't guess next code)
Fast (simple math, no database)

Submissions

Displaying Solutions with Scores Ranging from 1 to 10