Dr Milan Milanović

Kubernetes killed more startups than server crashes ever did

You don't have Spotify's scale. You have 8 engineers and a single server that's running fine

But you watched a KubeCon talk, and now you've got 23 YAML files, a Helm chart nobody fully understands, and engineers debugging pod evictions instead of buildinga product

Your "cloud-native infrastructure" is just a cloud bill with extra complexity

A $50/month VM can handle millions of requests. Your startup will run out of money debugging networking issues long before you need horizontal pod autoscaling

The best infrastructure decision is often the simplest one

Software developers are lifelong learners

Not because we're curious. Because we have no choice

The tools change. The frameworks shift. The best practices from last year have become antipatterns today

You either keep learning or you become obsolete.

Read more code than you write. Build things outside your job's stack. Learn one new language every 2-3 years. Follow people who challenge what you think you know

The learning never stops. That's the job

If you're a developer who ships code daily, remember these:

- First, make it work; nobody cares how elegant broken code is
- Then make it fast, slow code that works still frustrates users
- After that, make it pretty, so that your teammates read code more than they write it
- Add tests that actually catch bugs, not just boost coverage metrics
- Refactor when you finally understand what you're building (usually the second time through)

Perfect code on the first try is a myth.

Fast iteration beats slow perfection every time

Be a software engineer, not a developer

AI can write code now. That part of the job is shrinking fast

Developers ask: "How do I code this?"
Engineers ask: "Should we build this at all?"

AI handles the first question better every month. The second? Still 100% human

System design. Architecture trade-offs. Understanding the business. Making it work in production

That's engineering. And it's not getting automated

The question isn't whether AI will replace developers. It's whether you're still just a developer

Friday Developers Fun 🤣

Cloudflare announced a new service recently

#developers #softwareengineering #meme

Walking is the best debugger

Your brain works better when you stop trying

Stuck on a problem? Walk away. Take a shower. Sleep on it. Your conscious mind steps aside, and something else takes over

The subconscious doesn't work linearly. It connects patterns you didn't see while staring at the screen. It runs in the background, rearranging pieces until something clicks

Then the answer arrives, fully formed, obvious in hindsight

You can't force insight. But you can create the conditions for it. Movement helps. Distance helps. Boredom helps

Next time you're stuck, close the laptop. The solution finds you when you're not looking

Clean code is too clean to make money

Clean code optimizes for maintainers
Money optimizes for customers

Customers don’t pay for elegance
They pay for speed, reliability, and outcomes

Ship a thin slice that solves one painful problem
Measure usage
Fix what breaks
Refactor what earns

𝗥𝗲𝗮𝗱𝗮𝗯𝗹𝗲 𝗰𝗼𝗱𝗲 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝗹𝗲𝘃𝗲𝗿𝗮𝗴𝗲 𝗲𝗾𝘂𝗮𝗹𝘀 𝗵𝗼𝗯𝗯𝘆 𝗰𝗼𝗱𝗲

Where do you draw the line: “clean enough” or “clean forever”?

The best software engineers I know don't obsess over the latest framework

They obsess over solving the actual problem

They write code that humans can read 
They ship working software over perfect architecture
They delete more than they write
They know the best code is the code you don't have to maintain

Your users don't care about your stack. They care that it works

That's the only metric that matters

The fear isn’t that AI will replace developers

The fear is that AI will replace the software development process we’re used to

Code is becoming cheap
Decisions are becoming expensive

AI can write functions all day, but it can’t decide what should be built, how it fits the system, or why it solves the problem. That part still sits with people who understand architecture, trade-offs, constraints, and consequences

The shift is simple:

Developers who only implement tasks will struggle
Developers who understand the product, the domain, and the system will thrive

AI reduces typing, not thinking. It accelerates engineers who treat code as leverage, not output. It exposes shallow understanding and rewards clarity, reasoning, and ownership

Small teams will ship things that once required entire departments.
The bar moves from writing code to shaping it

AI won’t replace developers
But it will replace developers who don’t grow beyond writing code

And if this transition feels uncomfortable, that’s normal. Every major shift starts that way. What matters now isn’t fear, it’s staying curious, learning fast, and leaning into the parts of engineering that AI can’t automate

Who remembers this from the 1990s, before the Internet?

It was a Wikipedia before Wikipedia

I wanted to understand how GPT works, so I ported Karpathy's microgpt.py to C# from scratch. No frameworks and NuGet packages, just plain math in ~600 lines of code.

It builds a tiny GPT that learns from 32K human names and invents new ones. Every piece is there: autograd, attention, Adam optimizer, the works. Just at a scale you can actually sit down and read.

I also wrote a prerequisites guide that walks through all the math and ML you need, starting at a high school level. If you've ever wanted to peek under the hood of ChatGPT without drowning in linear algebra textbooks, this might help.

With time, one thing became clear:
People either respect you, or they don’t

You can explain, justify, and prove, but it won’t change much

I stopped trying to win everyone over

I focus on people who value my work, my time, and my presence

Everything else is noise

LinkedIn today, 99% slop posts straight LLM outputs

Every post has the same pattern

Same hook, same bulleted points, same “agree” at the end

Most of the comments are either bots or people adding comments just to increase their own visibility

Really wierd to witness this

I've reviewed 1,000+ resumes as a hiring manager

Most get rejected in 6 seconds

Here's what separates the ones that land interviews:

𝟭. 𝗢𝗻𝗲 𝗽𝗮𝗴𝗲. 𝗣𝗲𝗿𝗶𝗼𝗱.

If you can't distill 10 years into one page, you don't understand what matters. Senior roles included.

𝟮. 𝗟𝗲𝗮𝗱 𝘄𝗶𝘁𝗵 𝗶𝗺𝗽𝗮𝗰𝘁, 𝗻𝗼𝘁 𝗿𝗲𝘀𝗽𝗼𝗻𝘀𝗶𝗯𝗶𝗹𝗶𝘁𝗶𝗲𝘀

❌ Bad: "Responsible for maintaining authentication service."
✅ Good: "Cut login failures by 40% by rebuilding authentication with Redis caching."

Metrics tell me you understand business outcomes.

𝟯. 𝗦𝘁𝗿𝗼𝗻𝗴 𝘃𝗲𝗿𝗯𝘀 𝗮𝘁 𝘁𝗵𝗲 𝘀𝘁𝗮𝗿𝘁 𝗼𝗳 𝗲𝘃𝗲𝗿𝘆 𝗹𝗶𝗻𝗲

Recruiters scan in an F-pattern. They read the first 2-3 words per bullet.

✅ Use: Built, Led, Reduced, Scaled, Architected
❌ Avoid: Assisted, Helped, Worked on

𝟰. 𝗞𝗶𝗹𝗹 𝘁𝗵𝗲 𝗯𝘂𝘇𝘇𝘄𝗼𝗿𝗱𝘀

"Visionary leader driving transformational initiatives with cutting-edge AI solutions" = noise.

Just say what you did and what changed.

𝟱. 𝗧𝗼𝗽 𝟭/𝟯 𝗴𝗲𝘁𝘀 𝟴𝟬% 𝗼𝗳 𝗮𝘁𝘁𝗲𝗻𝘁𝗶𝗼𝗻

Polish your first section obsessively. That's where hiring decisions happen.

𝟲. 𝗧𝗮𝗶𝗹𝗼𝗿 𝗳𝗼𝗿 𝗲𝗮𝗰𝗵 𝗿𝗼𝗹𝗲

One resume for all jobs = one resume that fits none. Match your bullets to the job description.

𝟳. 𝗡𝗼 𝘀𝗽𝗲𝗹𝗹𝗶𝗻𝗴 𝗲𝗿𝗿𝗼𝗿𝘀

If you can't proofread when it matters most, I won't trust you with production code.

___
👉 Want the template I give to my coaching clients? Grab it in my Premium Resume Package: https://lnkd.in/dqZ2m-fb