Technical debt is a former technical asset without its owner.
The older and more experienced I get, the more I lean towards not implementing anything more than the bare minimum.
I think juniors are more prone to building supposed "technical assets" in the hope it might get used. This could be microservices or a nosql db, or kubernetes operators, etc. Part of this is just a desire to try things and do some resume driven development (which I guess is fair). These things do inevitably end up being tech debt a good portion of the time, though the other portion are good innovations which unlock opportunities.
With experience comes an appreciation of what is really needed and a knowing of what is needless, and also the ability to create a solution closer to when it is needed (both because one is quicker at coding it, and because with a delay comes better data and thinking on the solution).
I think building a good theory and consensus among the team ahead of time might be a better use of time.
Some people see technical debt as a list of missing features, but it should be a list of the problems that you know you have to vs want to solve. The list can vary but should include known bugs and errors in your code. It should also include how readable your code is and any bloat you might carry. Slowness in build and execution time needs consideration as well.
I can't believe people are still talking about tech debt like it's a real thing.
Debt is the amount owed on a loan. There is no loan taken out, nor terms. There is no creditor. There is no term sheet. There is no capital. There is no security. There is no debt. It's imaginary. Not imaginary like how money is imaginary. It literally does not exist, in any way shape or form, other than as myth, parable, metaphor, or ghost story. Better not incur tech debt, the boogie man will get ya! (Or, as is much more popular as a rationalization: that debt as fiscal policy is actually a good thing, so 'tech debt' must similarly be good)
If it was real debt, the bank would have called in their loans on the deadbeats and forced them to fix their shit, far more often than actually happens. But it's not debt. It's just lazy people putting off what they don't feel like doing.
The idea behind tech debt is just the state of cheating yourself by doing a shitty thing for short-term gain. It has nothing to do with money. It's an intellectual rationalization for being lazy. ("Hey, it's no big deal that I didn't add security to the web service, it's just tech debt! I'll pay it back later!")
It's like drinking too much booze, eating too much pizza, and not working out, because it's easier to do that now, with the promise of working out later to relieve the "debt". But you never stop pigging out, and you never start working out. It's just cheating yourself in the future to be lazy today with no material consequence.
Also worth noting that you can create new debts while paying old ones, and sometimes you should.
A debt vs an asset is a matter of context and perspective more than an essential property.
Data may be an asset for you. But the very same data may because a debt (because it becomes hard to keep relevant or accurate) or even a burden (because it exposes you to unwanted disclosures and potential commercial and legal consequences).
Remember having a very hard time explaining to three (of course non-technical) cofounders of a… peculiar online payment platform that hoarding all payment and behavior stats of users was maybe not the rich and lucrative endeavor they were looking for if they did not put the required effort in the design and multi-level security of the storage. What was bound to happen, happened.
technical debt is product leverage
As an engineer I see every piece of added complexity as a carrier of a little bit of liability. Yes that piece might add functionality, increase reliability an such, but it also needs to be maintained, understood, documented and increases the complexity of the whole (and thus makes it unlikelier to some random developer just understanding it).
Technical debt is when pieces of your code cannot simply be maintained and understood, or when these pieces produce constant maintenance issues because they have been assembled the wrong way or a dependency is no longer maintained itself.
Good code is code that people want to maintain.