Tech is not about solving problems. It's about choosing the price to pay.

Hello my friends,

Lately, I’ve moved into a new environment and had the chance to be trained directly by a CTO. At first, I thought to myself:

“Probably just some theoretical stuff, just listen to know.”

But surprisingly, the person who learned the most in that session was me. What I learned wasn’t a new technology, nor was it some high-level pattern. It was something that sounds very familiar:

Trade-off.

Before this, I also “knew” about trade-offs. Like: “Yeah, everything has its price.” But it stopped at just knowing.

After that time, it was different. I started thinking like this:

Every decision is a trade-off.

And you are forced to choose — even when you don’t want to.

A simple example

Building a product from scratch. There are 2 directions:

Option 1 — Doing it “by the book”

• Clean design
• Separate services
• Optimize performance → Takes a few months

Option 2 — Doing it fast

• Group logic together
• No need to scale yet
• As long as it runs → Takes 2 weeks

The real question is: Which one do you choose?

If you choose Option 1: → Beautiful system, scalable. → But maybe… you’ll never have users to scale for.

If you choose Option 2: → Fast product release. → But later, you’ll definitely have to pay the debt.

Neither is “right.” There is only: At this moment, what are you prioritizing?

AI doesn’t solve this

Many people now think: “We have AI now, no need to think about trade-offs. Just generate the code and you’re done.”

But that’s a trap. AI helps you code 10 times faster. → That also means you can create technical junk 10 times faster.

AI is like a supercar. If you don’t know whether you are on:

• A highway (need speed), or
• A narrow alley (need control) …then it only helps you hit the wall faster.

A smaller example, but happens every day

I once asked: “Do we really need a Repository here? Or are we just doing it because ‘people say we should’?”

Theoretically: → Repository helps decouple the DB, easy to change later.

But in reality:

• Small project.
• DB almost never changes. → Adding a Repository only makes the code more complex.

At that moment, I realized: Many times, we aren’t solving problems. We are just following standards — without knowing if they are even needed.

And the price to pay is:

• More code.
• Harder to read.
• More tiring to debug. …just to get something in return that… we might never actually use.

And there’s something even more annoying

After a while, I realized something else: Many times we think we are “choosing.” But actually… we don’t have as many choices as we think.

• Deadline is hitting.
• Small team.
• Product has no users yet. → You don’t have the right to make it beautiful.

Conversely:

• Have users.
• Have traffic.
• Have a team to maintain. → You aren’t allowed to do it sloppily anymore.

One stupid decision can be paid for with:

• Downtime.
• Loss of users.
• Loss of money.

Meaning: You don’t always get to choose the trade-off. The context chooses it for you first.

How I think now

Before, I used to ask: “Is this way good?” Now, I ask:

• When should I hack it?
• When must it be done “properly”?
• And what are the signs that I’m choosing wrong?

Very straight examples:

• No users yet → Prioritize speed.
• Already have users → Prioritize stability.
• Coding alone → You can be reckless.
• Coding with a team → You no longer have the right to be selfish.

Ending

Finally, I realized something very simple: Trade-off isn’t about which one you like. It’s about which price the circumstances allow you to pay.

And a bit deeper:

You don’t solve problems. You only choose which problems to accept.