What is a UUID?
Learn Everything About Universal Unique Identifiers
Step-by-Step Guides and Expert Articles on Creating, Using, and Understanding UUIDs in Software Development and Data Management
Benchmarking UUID Generation in Python: Speed vs. Randomness Trade-offs
This article benchmarks Python’s UUID generation methods (v1, v4, v5) to compare their speed, randomness, and practical use cases. It includes performance data, security insights, and real-world recommendations for APIs, logs, and scalable systems.
What is the better alternative to UUID?
This article explores modern alternatives to UUIDs, including ULIDs, KSUIDs, and NanoIDs. It compares them in terms of readability, performance, and suitability for different use cases.
Beyond UUIDs: The Next Generation of Distributed Identifiers
This article explores what comes after UUIDs in the world of distributed systems. From content-addressable hashes to decentralized and cryptographic identifiers, we break down emerging ID strategies shaping the future of software architecture.
Binary UUIDs: Storage, Byte Order, and Database Examples
Store UUIDs in 16 bytes, convert them safely in MySQL, PostgreSQL, MongoDB, Python, and Node.js, and measure the performance trade-offs.
Can a UUID be traced?
This article answers whether UUIDs can be traced back to a user, device, or system, and under what circumstances privacy concerns may arise.
Collision Course: The Real Mathematics Behind UUID Uniqueness
This article explores the real mathematics behind UUID uniqueness using probability theory and the birthday problem. Learn how collision risks are calculated and why UUIDv4 remains safe for use even at massive scales.
COMB GUIDs: The Hybrid Approach That Gives You the Best of Both Worlds
This article explains COMB GUIDs — a hybrid identifier that blends UUID randomness with timestamp ordering for improved database performance. Learn how they work, why they matter, and how to implement them across languages like C#, Java, and Python.
The Comedy of UUID Errors: Real Support Tickets I've Seen
This lighthearted article explores some of the funniest and most frustrating UUID-related support tickets developers have encountered. From truncated IDs to copy-paste fails, it highlights common pitfalls with a dose of humor and practical lessons.
Converting Between UUID Versions: When and How to Transform Your Identifiers
This article provides a comprehensive guide to converting between UUID versions, offering practical examples and strategies for migrating identifiers across v1, v4, v5, and v7 while preserving uniqueness and intent.
Building a Custom GUID Generator in Rust
This detailed Rust tutorial walks through building a custom GUID generator from scratch. Learn the algorithm, performance techniques, and implementation patterns for generating UUID-like identifiers efficiently in Rust.
Database Migrations: Converting Legacy IDs to UUIDs Without Downtime
This article provides a zero-downtime, step-by-step strategy for migrating legacy auto-increment IDs to UUIDs in live production databases. It covers schema evolution, dual writes, backfills, and cutover techniques with minimal risk.
Domain-Specific UUIDs: When Standard Formats Aren't Enough
This article explores how niche domains like gaming, telecom, and IoT use custom UUID formats to meet unique constraints. Learn when standard UUIDs fall short and how tailored formats can improve efficiency, traceability, and system design.
The Environmental Impact of UUIDs: A Byte Too Far?
This article explores the environmental and performance impacts of UUID usage in large-scale systems, using humor and hard numbers to evaluate the storage, indexing, and energy costs of these 16-byte identifiers.
Fingerprinting Browsers with UUID Generation Techniques
This article examines how UUID generation methods in the browser can be exploited for user fingerprinting, exploring the privacy risks and offering clear mitigation strategies to protect user anonymity in modern web applications.
What can hackers do with UUID?
This article examines how UUIDs can be exploited by malicious actors in web applications, including enumeration attacks, metadata leakage, and strategies to secure your implementation.
Building a High-Performance UUID Generation Service in Go
This detailed tutorial walks through creating a high-performance UUID generation microservice using Go, focusing on scalability, throughput, and distributed systems design to handle millions of requests per second.
Meet ULID: The Sortable UUID Alternative You Should Consider
This article introduces ULIDs (Universally Unique Lexicographically Sortable Identifiers) as a powerful, sortable alternative to UUIDs. It explains how ULIDs work, why they matter, and where they outperform traditional identifiers in distributed systems.
Multi-Tenant UUIDs: Keys, Authorization, and Data Isolation
Design tenant-scoped UUID keys and relationships without confusing identifiers with authorization. Includes a PostgreSQL schema and cross-tenant test scenarios.
UUID Collision Probability: What 100 Million IDs Really Means
Calculate UUID v4 collision odds, distinguish pairwise probability from collection risk, and understand why testing cannot prove uniqueness.
PostgreSQL and UUIDs: Leveraging Native UUID Types for Fun and Profit
This article explores PostgreSQL’s native UUID support with a focus on performance, storage optimization, and indexing. Learn how to use UUIDs efficiently in your database schema and queries — with practical examples and best practices.
The Psychology of UUIDs: Why Random Strings Feel More "Secure"
This article explores the cognitive biases behind why developers and users perceive random-looking UUIDs as more secure. Blending psychology with software engineering, it examines the false comfort of entropy and the risks of mistaking randomness for safety.
Snowflakes vs. UUIDs: When Twitter's Identifier Scheme Makes Sense
This article compares Twitter's Snowflake ID system with conventional UUIDs, evaluating their performance, scalability, and real-world applicability in high-throughput distributed systems.
The Surprising History of UUIDs: From Apollo Missions to Your Web App
This article traces the evolution of UUIDs from early computing roots to modern distributed systems. It covers their conceptual origin, formal standardization, and widespread adoption — from NASA’s mission-critical engineering to today’s microservices and APIs.
Testing UUID-Heavy Systems: Mocking, Seeding, and Verification
This article explores robust strategies for testing systems that rely heavily on UUIDs, including techniques for mocking, seeding, and ensuring reproducible and deterministic behavior in your tests.
Time-Based UUIDs: Leveraging Version 1 for Chronological Ordering
This article explores UUIDv1 — the time-based version — showing how it enables chronological ordering and supports time-series data. Includes practical code examples and best practices for real-world implementation.
The Complete UUID Cheat Sheet — RFC 9562
A practical reference for UUID versions, generation, inspection, storage, and identifier selection under RFC 9562.
URL-Safe UUIDs: Compressing 36 Characters Into 22
This article explains how to transform standard UUIDs into compact, URL-safe formats using Base64 encoding. Includes code examples, best practices, and guidance for safely shortening UUIDs without compromising uniqueness.
Is UUID always 36 characters?
This article explains the structure of UUIDs, why they are typically 36 characters long, and what causes variations in length across different formats or encodings.
UUID Canonicalization: The Surprisingly Complex Problem of String Formatting
This article explores the often-overlooked complexity of UUID canonicalization, covering string formatting, case sensitivity, and standardization, with practical solutions for consistent representation.
What is a UUID generator used for?
This article explores what a UUID generator is used for, how it ensures uniqueness in systems, APIs, and databases, and where it shines in modern development practices.
UUID Security: When Randomness Isn't Random Enough
This article explores the security vulnerabilities of UUID generation, focusing on poor randomness, predictability, and exposure risks. It offers guidelines for generating secure, unpredictable UUIDs and avoiding common implementation mistakes.
UUID-Based Sharding: Routing, Locality, and Hotspots
Choose a UUID shard key based on your queries. Compare hashing, tenant routing, and time ranges, with a Python example that normalizes UUIDs before routing.
UUID Stories: Tales from the Trenches of Distributed Computing
This article compiles real-world stories from engineers working with UUIDs in distributed systems — covering painful lessons, unexpected collisions (or the illusion of them), and clever solutions to tricky problems in microservices, logging, and beyond.
UUID Examples and Test Vectors: Versions, Timestamps, and Bytes
Fixed UUID examples with expected versions, a decoded v7 timestamp, byte-order checks, and executable Python and JavaScript assertions.
UUID Version 7: Layout, Generation, and Ordering Limits
Understand UUID v7 timestamps, random and counter fields, working Python and Node.js examples, and the limits of time-based ordering.
UUID Version 8: Customising Your Identifiers While Maintaining Standards
This article explores the power and flexibility of UUID Version 8, introduced in RFC 9562, to create custom identifiers for specific system needs while still complying with the UUID format. Includes implementation examples and best practices.
UUIDs 101: Format, Versions, and Practical Examples
Learn what UUIDs identify, how to choose v4, v5, or v7, and how to generate and validate them without confusing uniqueness with security.
UUID Database Performance: What to Measure Before Changing Keys
Compare UUID storage and index behavior in PostgreSQL, MySQL, and MongoDB, with a PostgreSQL measurement example and no invented benchmark results.
UUIDs in Distributed Event Sourcing: Patterns and Pitfalls
This article explores how UUIDs power distributed event sourcing systems, helping ensure idempotency, event identity, and ordering. It unpacks common patterns, anti-patterns, and actionable strategies to avoid subtle bugs.
UUIDs are the Horoscopes of Modern Microservices
A humorous yet insightful take on how UUIDs have taken on mythic importance in modern microservice culture. From false guarantees to fortune-cookie uniqueness, this post explores how we treat UUIDs like fate.
"UUIDs in 10 Languages" Part 1: UUID Generation in C and C++
This article explores UUID generation in C and C++, the foundational languages for many system-level and performance-critical applications. Learn how to generate, format, and use UUIDs using standard libraries and best practices.
"UUIDs in 10 Languages" Part 2: Rust, Go, and C#
This article explores UUID generation in Rust, Go, and C#, complete with best practices, code examples, and language-specific implementation tips. Learn how to properly use UUIDs in distributed systems across these three modern ecosystems.
"UUIDs in 10 Languages" Part 3: Ruby, PHP, and TypeScript
This article explores UUID generation in Ruby, PHP, and TypeScript with code examples and best practices. Learn how each language handles UUID creation, formatting, and validation in modern distributed systems.
"UUIDs in 10 Languages" Part 4: Swift, Kotlin, and Elixir
This article explores how to generate and use UUIDs in Swift, Kotlin, and Elixir — with practical code examples and language-specific best practices. Perfect for mobile and functional developers working in distributed environments.
"UUIDs in 10 Languages" Part 5: C++, Scala, and Dart
This article explores how to generate and manage UUIDs in C++, Scala, and Dart — with practical examples tailored to each language's ecosystem. Learn how to implement UUIDs safely and effectively in your systems.
"UUIDs in 10 Languages" Part 6: Clojure, Haskell, and R
This article wraps up the UUID language series with insights into UUID generation in Clojure, Haskell, and R. It includes practical code examples and usage tips tailored to functional and data-centric programming environments.
"UUIDs in 10 Languages" Part 7: UUID Generation in Even More Languages
This bonus entry in the UUID series expands beyond the initial 10 languages to include UUID generation in TypeScript, Scala, SQL (PostgreSQL/MySQL), Elixir/Erlang, and Bash. With idiomatic examples and key tips, you'll be UUID-ready across any tech stack.
UUIDs in Blockchain: How Distributed Ledgers Handle Unique Identifiers
This article explores how UUIDs intersect with blockchain technology, comparing traditional unique identifiers to cryptographic transaction hashes and smart contract addresses, while highlighting where UUIDs still provide value in hybrid and off-chain systems.
UUIDs Are Not Encryption: Stop Using Them to Hide Information
This article dispels the myth that UUIDs can secure or encrypt data. It explains what UUIDs are actually designed for, why they’re not a security measure, and what developers should use instead to protect sensitive information.
UUIDs in RESTful API Design: Best Practices in 2024
This article outlines the best practices for integrating UUIDs into RESTful API design, offering guidance on their use in URL paths, query parameters, and backend validation to build more scalable and secure APIs.
UUIDs vs. Auto-increment IDs: The Holy War of Database Primary Keys
This article examines the long-standing debate between UUIDs and auto-incrementing integers as database primary keys. It compares their performance, scalability, predictability, and best practices across systems like PostgreSQL and MySQL.
UUIDs vs. Nano IDs: When Smaller Is Better
This article compares traditional 36-character UUIDs with compact Nano IDs. It explores their differences in length, performance, security, and use cases — and helps you decide which identifier fits your application best.
What can a UUID tell you?
This article explores what information can be extracted from different UUID versions, revealing how some UUIDs may encode timestamps, MAC addresses, or randomness, and what that implies for privacy and system design.
"The Worst Uses of UUIDs I've Seen" Part 1: Database Horror Stories
This article kicks off a series exposing real-world UUID misuse in databases. From storage disasters to query nightmares, it recounts actual stories, explains what went wrong, and delivers lessons to avoid repeating the same mistakes.
"The Worst Uses of UUIDs I've Seen" Part 2: API Antipatterns
This article explores real-world examples of UUID misuse in API design — from leaky abstractions to security flaws — and shares practical advice to help you avoid the most common and cringe-worthy antipatterns.
"The Worst Uses of UUIDs I've Seen" Part 3: Distributed Systems Failures
This article concludes the UUID horror story series by diving into distributed system failures caused by UUID misuse. Through real-world case studies, it highlights consistency issues, architectural mistakes, and how to avoid them.
Year in Review: UUID Trends and Developments in 2024
This article reflects on the most significant trends and changes in UUID usage and standards during 2024, including new versions, community adoption, tooling improvements, and evolving best practices for distributed systems.