Modern data teams are quietly hitting a wall, and it has nothing to do with compute power or storage costs. The wall is the sequence, that humble database feature designed for a simpler era when auto-incrementing IDs were enough. As your data grows and your workloads scale across distributed systems, those sequential integers become a bottleneck, a single point of contention that slows down writes and forces awkward workarounds. We think it is time to stop treating sequences as an immutable law of databases and start seeing them for what they are: a legacy constraint that you can, and should, design around.
The practical implication here is not that you need to rip out your existing infrastructure overnight. It is that the next time you architect a new service or refactor an existing table, you have a real choice. Instead of accepting the sequence limit as a fixed ceiling, you can adopt a strategy that decouples ID generation from the transactional write path. This is not about chasing some exotic technology; it is about recognizing that the patterns that worked for a single-node relational database in 2005 are not optimized for the distributed, horizontally scaled systems you are running today. The path forward involves generating unique identifiers in a way that is inherently parallel, removing the serialization point that sequences impose.
What does that mean for you on a Tuesday morning? It means fewer lock waits, higher write throughput, and a system that does not degrade as you add more shards or nodes. It means not having to babysit your sequence cache or worry about gaps causing operational headaches downstream. The shift is subtle but profound: you move from a model where the database is the arbiter of uniqueness to one where your application layer or a dedicated ID service can produce collision-resistant values independently. This is not a hypothetical benefit; it is a concrete architectural decision that pays off in resilience and elasticity, especially when you are dealing with multi-region deployments or bursty traffic patterns.
We are not saying sequences are evil or that you should purge them from every corner of your stack. But we are saying that the default assumption, that you must use them because that is how it has always been done, is a trap. The most practical thing you can do is audit where your sequences are currently creating contention and evaluate an alternative for those specific paths. Start small, maybe with a high-volume event table or a logging service, and measure the difference. You will likely find that the ceiling you were scaling against was not a law of physics but a design choice. And that is a choice you are now empowered to make differently.