System Design 102 - Unique ID Generators

System Design 102 - Unique ID Generators

In today's digital landscape, unique identification (ID) is paramount in systems architecture, databases, distributed systems, and more. From ensuring no two users have the same ID in a social network to ensuring unique transactions in a distributed database, a unique ID generation mechanism is critical.

In this post, we'll take a comprehensive dive into unique ID generators, their importance, various algorithms, real-world implementations, and best practices.

Why Unique IDs?

Unique IDs ensure:

  • Data Integrity: Without unique IDs, data anomalies can occur, causing chaos in systems. Think of a user signing up on Facebook. Without unique IDs, two users might end up sharing the same ID, causing a mix-up of data.

  • Ordering: In distributed systems, unique IDs often provide a temporal sequence. For platforms like Twitter, every tweet has a unique ID that also tells us its chronological order.

  • Reference: IDs help in data retrieval, forming the cornerstone of primary and foreign keys in databases. In Amazon's vast inventory, unique product IDs ensure you get the exact item you ordered.

Types of Unique ID Generators

Sequential ID Generators

Classic databases like MySQL or PostgreSQL use auto-incrementing IDs. As data gets inserted, the ID increases sequentially.


  • Predictable and easy to debug.

  • Offers chronological order.


  • Limited scalability across distributed systems.

  • Possible ID exhaustion.

Real-World Implementation: Traditional RDBMS (like MySQL's AUTO_INCREMENT).

UUID (Universally Unique Identifier)

UUIDs are 128-bit numbers, commonly displayed as 32 hexadecimal digits separated by hyphens.


  • Highly unique across space and time.

  • Decentralized generation, good for distributed systems.


  • Size: Takes up more storage.

  • Not sequential, hence may lead to inefficient database indexing.

Real-World Implementation: Almost all programming languages have libraries to generate UUIDs, e.g., Java’s UUID.randomUUID().

Flake IDs

Flake IDs are distributed unique ID generators. They mix timestamp bits, machine identifiers, and sequence numbers.


  • Suitable for distributed systems.

  • Offers time-ordered IDs.


  • Rely on system clocks; if not synchronized, it might cause issues.

Real-World Implementation: Twitter's Snowflake.

Database-Driven Unique ID Generators

Some databases, like MongoDB, offer their unique ID generation mechanism, producing a unique identifier with a timestamp.


  • Integrated within the database system.

  • Offer insights into the insertion time.


  • Tied to a specific database.

Real-World Implementation: MongoDB’s ObjectId.

Custom ID Generators

Enterprises sometimes roll out their custom ID generators based on business rules.


  • High flexibility.

  • Tailored to specific needs.


  • Development overhead.

  • Potential pitfalls if not correctly implemented.

Best Practices in Using Unique ID Generators

  1. Scalability: Always consider future scale. UUIDs might be overkill for a small system but essential for a global, distributed system. E.g. When Instagram started, they never anticipated the billions of photos they'd host. Their ID system had to evolve.

  2. Database Performance: UUIDs, if not stored or indexed correctly, can affect database performance. E.g. Airbnb, with millions of listings, needs efficient indexing to quickly fetch data.

  3. Consistency: In distributed systems, network partitions can cause issues. It's crucial to decide between consistency and availability based on the system's needs. E.g. If Netflix’s systems in the U.S. and Europe aren’t consistent, you might not resume your movie where you left off.

  4. Avoiding Collisions: Especially in custom ID generators, ensure algorithms effectively avoid ID collisions. E.g. Spotify can't afford two songs to have the same ID.

Real-World Case: Twitter's Snowflake

Twitter required a system that could generate hundreds of thousands of unique IDs per second for tweets across multiple servers. Enter Snowflake, a distributed ID generator.

Twitter’s Snowflake system has become a hallmark example of a distributed unique ID generator. Given Twitter's vast user base and the sheer volume of tweets being created every second, they needed an ID system that was scalable, efficient, and capable of generating unique IDs at a massive scale. Snowflake rose to this challenge. Here’s a deeper dive into its workings and brilliance.

The Architecture

Snowflake's ID generation process is a blend of multiple components:

  • Timestamp: This is a 41-bit field that denotes the milliseconds since a custom epoch. Given the bit-length, Snowflake can represent a time range of about 69 years. This ensures time-based ordering of IDs, meaning tweets can be sorted chronologically based on their IDs alone.

  • Machine ID: An 10-bit field representing the machine or worker. This allows Snowflake to run on up to 1024 machines.

  • Sequence Number: A 12-bit field that represents a counter for IDs generated in the same millisecond. This ensures that up to 4096 unique IDs can be generated every millisecond on a single machine.

In total, these components form a 63-bit integer (with the first bit unused to ensure positive IDs). The resulting IDs are both unique and sortable.


  • Distributed: Since machine IDs are part of the unique identifier, multiple servers can generate IDs simultaneously without collisions.

  • Time-ordered: Given the timestamp's position, sorting IDs will inherently sort them in the order they were created.

  • Customizable: The bit lengths can be modified based on needs. If more machines or higher throughput in the same millisecond are needed, bit lengths can be adjusted.

Challenges & Considerations

  • Clock Skew: If a machine's clock goes backwards, there's a risk of generating duplicate IDs. Snowflake has safeguards to handle such situations, waiting to ensure uniqueness.

  • Machine Failures: With the machine ID encoded, if a machine fails, other machines can still generate IDs.

  • ID Exhaustion: Given the bit allocation, there's a theoretical limit to the number of IDs Snowflake can generate. However, this is so vast that it's unlikely to be reached.

Adaptability & Implementations

The Snowflake model is not just confined to Twitter. Its principles are adaptable, and several implementations and variations exist across different platforms and languages. Whether you're working in Java, Go, or any other language, there’s likely a Snowflake-inspired library available.

Show Me Some Code

For those who are intrigued by Twitter's Snowflake and wish to see a streamlined version of it, there's good news. I have created an implementation inspired by Snowflake which serves as a great starting point for those looking to grasp the mechanics without delving deep into the complexities.

Features & Highlights:

  • Open-Source Code: The codebase is freely accessible, allowing enthusiasts and developers to study, modify, and even contribute.

  • Simplified Approach: For learners or those initiating their journey into distributed systems, this is an excellent place to start. The implementation offers clarity without the clutter of large-scale system intricacies.

  • Hands-On Learning: Instead of just reading about Snowflake, you can actively engage, experiment, and even test this system to get a real feel for how unique ID generation works in distributed scenarios.

Access & Contribution:

The project is hosted on GitHub and can be accessed here.

Developers and enthusiasts are encouraged to explore the repository, star it for reference, and even fork it for their experiments.


The world of unique ID generators is vast, and the choice depends on the problem domain. Whether it's the global uniqueness of UUIDs, the distributed efficiency of Snowflake, or the simplicity of sequential IDs, understanding the strengths and weaknesses of each is crucial for system designers and architects.

Thank you for staying with me so far. Hope you liked the article. You can connect with me on LinkedIn where I regularly discuss technology and life. Also, take a look at some of my other articles and my YouTube channel. Happy reading. 🙂


  1. Leach, P., Mealling, M., & Salz, R. (2005). A Universally Unique IDentifier (UUID) URN Namespace. IETF.

  2. Twitter Engineering. (2010). Announcing Snowflake.

  3. MongoDB Docs. ObjectId.