There is an old engineering habit I see over and over: learn a handful of tools very deeply, and then try to build every single future project exclusively with those tools.
On paper, the logic sounds safe. You know the query planner, you know where the configs live, and your team doesn't introduce another moving piece to the stack.
In practice, that mindset causes some of the nastiest technical debt I have ever had to untangle.
Take automation and industrial backend systems. A team gets hired primarily for their SQL background. They build the initial system around a relational database like Postgres or MySQL—storing users, device metadata, recipes, and schemas. That works fine.
Then the system grows, and they need to store high-frequency telemetry, sensor metrics, and execution logs from thousands of concurrent processes.
Right around the corner, there are time-series databases built specifically for this workload: append-only write streams, automatic downsampling, and rolling data retention.
Instead, the team adds a process_logs table to their relational database.
The developer doesn't want to step outside their SQL comfort zone, and the team lead is terrified of adding another database to the infrastructure.
Fast forward a year: that relational database is struggling with write locks. Tables have ballooned to hundreds of gigabytes. Backups take forever. So the team starts writing spaghetti workarounds: custom table partitioning cron jobs, manual cleanup scripts, and complex indexing hacks just to keep queries from timing out.
By the time it becomes a genuine operational headache, nobody can touch it. The workaround code is so tightly coupled to the rest of the application that moving to a proper time-series store means a painful, high-risk refactor.
They ended up with an unmaintainable legacy system because they picked what they already knew instead of what the problem actually needed.
Years ago, sticking to tools you already knew had a rational justification.
Adopting a completely different database or language meant reading through thick documentation for weeks, tripping over unfamiliar syntax, and making beginner mistakes in production. When the learning curve took months, forcing an existing tool to handle an unsuited workload could feel like an acceptable compromise.
That friction barely exists anymore.
With modern tooling, syntax is practically free. You do not need to memorize every command of an unfamiliar query dialect or runtime before you can use it effectively. If you understand the fundamental architecture—access patterns, memory constraints, network boundaries, and I/O mechanics—looking up syntax and boilerplates takes seconds.
You are no longer stuck with whatever stack you happened to work in five years ago. You can actually choose tools based on what fits the data and the problem.
Whenever I argue for picking specialized tools over familiar ones, people ask the same question:
If you don't have years of experience with this specific tool's syntax, how do you review pull requests and know the code is safe?
My answer: line-by-line syntax familiarity in code reviews was never what kept production safe anyway.
Look at the sheer volume of high-severity CVEs surfacing every single week across the industry. The libraries and utilities with critical vulnerabilities aren't written by engineers experimenting with new tools; they are maintained by veterans with twenty years of deep experience in C, Java, or Python. Deep familiarity with a language doesn't stop people from introducing fundamental bugs.
The real validation has always been what we built automated testing for:
- Strict end-to-end (E2E) suites.
- Automated regression tests.
- Clear contract testing at the API and service boundaries.
If a dedicated time-series engine ingests thousands of events per second with low resource overhead, and your automated test suite verifies that queries, rollups, and error cases return the expected results under load, you have a much cleaner system than an overloaded SQL instance propped up by custom cron scripts.
I would much rather introduce a new, well-suited tool to a stack than spend months writing duct-tape code to make an old tool do something it was never designed to do.
Syntax is easy to look up. Architectural mismatch is painful and expensive to undo.
Pick tools based on what the problem requires, write solid tests around the boundaries, and stop forcing one database or language to solve every problem just because it's what you learned first.