Many misconceptions arise around database reliability. We typically think in terms of availability (which more or less comes down to minimizing downtime), durability (so we don’t lose data), integrity (meaning that we don’t break the data), fault tolerance (we distribute databases), recoverability (we can still recover the data after issues), safety (who can access what), or performance (it must be fast). However, these categories do not capture what is truly important in databases. Let’s see 3 things that we overfocus on instead of seeing the big picture.
It’s not about doing things right. It’s about doing the right things
Technical people often overfocus on polishing and improving the solutions they know how to deliver. They prefer to use the same tools and just make them faster instead of understanding if other tools should be used. They are great at optimizing stuff and often they can improve performance, but they equally often limit the systems by sticking to the same old solutions.
True performance improvements come from changing the approach. It’s like with vehicles. We can make our bicycles faster, and often we can really double or even triple the speed. However, switching to a car will make it far better, even if the car is pretty mediocre.
Do not push your existing solutions like crazy. Look for better solutions instead!
This applies to database reliability as well. Consider replacing your existing databases with different ones. Consider using extensions tuned for specific workloads. Think about replacing your existing monitoring with better observability that can automate troubleshooting instead of just showing you signals. Be clever by doing the right things.
Recommended reading: Observability vs Monitoring - Key Differences & How They Pair
It’s not about being resilient to failures. It’s about preventing failures altogether
We often embrace reality instead of shaping it. We face issues and fix them instead of preventing them. We only cure the symptoms instead of the causes. While this can help us survive yet another day and maintain our business continuity, this is a very short-term solution.
Always fix the causes and prevent the failures altogether. Do not just cure symptoms.
For database reliability, this mostly comes from working on preventing the problems from happening instead of supercharging our remediation processes. It’s very similar to what we struggle with when moving to NoSQL databases that do not support ACID and transactions spanning multiple entities. We may be very clever in emulating SQL-like transactions in a NoSQL database, but maybe it’s just better to use SQL databases. Or, even better, consider if you need the transaction from a business perspective. Maybe you don’t need to modify multiple entities atomically at all.
The same happens for reacting to failures. We may build better solutions to recover the data when our single source of truth fails, but maybe we just shouldn’t have a single source of truth. Maybe we can prevent the failures by reshaping reality in a way that makes the failures simply impossible.
It’s not about improving once and for all. It’s about making things better continuously
We like to be perfect and use “the best” solutions everywhere. Life isn’t like this, unfortunately. There are no “best” solutions that work always and everywhere. In other words, every solution has its drawbacks and edge cases when it fails. If we don’t accept this fact, we may be tempted to look for the perfect solution that covers everything, never fails, and handles all the tricky cases.
Recommended reading: All Your Monitoring Solutions Are Wrong, Here's Why
The problem with such an approach is that we do not improve. We keep looking for these ideal solutions while still running current ones that we know are bad in many aspects. Effectively, we have so-so solutions forever because we never find the perfect ones. This is wrong.
Improve continuously. Do not reject better solutions just because they are not perfect. They are still better than what you have now.
For database reliability, we need to understand that medium improvements are better than no improvements at all because we’re still looking for something better. We don’t need to solve all our security challenges in one go. We may improve them step-by-step. We don’t need to find a way to improve all the queries and indexes at once. We can improve only some of them and still make our database better.
Last but not least, you’re never done improving. You will never find the perfect solution. Every day is a new day and brings new improvements.
How Metis Can Help
It’s always important to see the forest from the trees. Do not overfocus on solutions and approaches you use today. Look for completely new ways of doing things to improve your performance and avoid problems. And always remember to improve continuously. It’s better to make a small step instead of not moving forward at all.
Metis can help you in this journey. You need to replace your monitoring with observability that understands databases. You need to prevent the bad changes from reaching production. Last but not least, you need to troubleshoot issues faster and automate as much as possible. Metis does all you need. It analyzes your code changes, schema migration, execution plans, and performance of your database queries to make sure you do the right things. Metis helps you throughout your deployment pipelines and can project changes on your production database to let you know in advance if things will work well. Metis constantly oversees your schemas, configurations, extensions, and live queries to improve them and give you clarity on how things evolve. You can use Metis to improve your databases and focus on what’s important for your business.
