A 5-Year Roadmap Back to Strong Fundamentals

In 2018, I started my bachelor’s degree in Computer Engineering with almost no real passion for it.

At the time, I was just there to get a degree.

I attended classes, did assignments, passed exams, and moved forward because that was the expected path. Programming was simply another subject to survive. But somewhere along the way, something changed. Little by little, I started enjoying the process of building things. Not just writing code, but understanding systems. Understanding why things break. Understanding why some designs scale while others collapse like wet cardboard castles under production traffic.

By 2024, I landed an internship as a junior Angular developer. That experience changed a lot for me. For the first time, programming stopped feeling academic and started feeling alive. Real projects. Real problems. Real consequences. I finally felt connected to the craft.

Then came the era of LLMs.

Like many people, I started using them to speed things up. At first, it was harmless. Small questions. Boilerplate. Debugging assistance. Then slowly, without realizing it, I became what the internet calls a “vibe coder.”

I stopped solving problems properly.

Instead of thinking through implementation details, I started outsourcing the thinking itself. Homework became prompts. Bugs became prompts. Entire features became prompts. And because the results worked most of the time, I convinced myself I was still learning.

But I wasn’t.

After finishing my bachelor’s degree, I got accepted into a Cybersecurity master’s program. That experience gave me a completely different perspective on software engineering. I started seeing systems from the security side: trust boundaries, attack surfaces, infrastructure, protocols, reliability, operational risk. Software stopped being “just code.” It became architecture.

The program was difficult enough that I had to leave my internship and fully focus on studying.

And somewhere during all of this, I lost something important.

One day, I decided to write a simple C++ program I had written before. Nothing complicated. Just basic logic.

My mind went blank.

Not “I forgot a syntax detail” blank.

I mean genuinely blank.

I realized I had become dependent on AI to the point where I had weakened my own ability to think through code independently. That moment hit me harder than any failed exam ever could. It felt like discovering that the engine inside the machine had quietly rusted while the dashboard lights still looked fine.

That was the wake-up call.

So I made a decision:

I’m going back to fundamentals. Properly this time.

Not for grades.
Not for tutorials.
Not for productivity dopamine.
For mastery.

I built a long-term roadmap for myself. A 4 to 5 year journey focused on rebuilding my foundations from the ground up and growing into the kind of engineer I actually want to become.

The goal is not speed.

The goal is depth.

The Roadmap

Phase 1: C and Linux Fundamentals

This is where I start rebuilding my low-level understanding of systems. Memory, processes, pointers, filesystems, shells, tooling. No abstractions to hide behind.

Phase 2: Python, Bash, and Operating Systems

Automation, scripting, internals, process management, scheduling, concurrency, permissions. Learning how machines actually behave beneath the UI layer.

Phase 3: Networks and the Internet

Protocols, routing, DNS, TCP/IP, HTTP, sockets, infrastructure communication. The invisible highways everything depends on.

Phase 4: Docker and Kubernetes

Containers, orchestration, deployment models, scalability, infrastructure management. Modern software engineering’s giant mechanical spiderweb.

Phase 5: CI/CD and Security

Pipelines, DevSecOps practices, hardening, monitoring, secrets management, secure deployment workflows.

Phase 6: Rust

Because I want to learn systems programming with modern safety guarantees while still staying close to the metal.

Phase 7: Databases and Distributed Systems

Replication, consistency, CAP theorem, transactions, fault tolerance, system design. This is where software starts becoming architecture.

Phase 8: C++

Returning to the language that exposed my weaknesses in the first place. This time with real understanding behind it.

Phase 9: Elixir and Haskell

Not because they are trendy, but because they force different ways of thinking. Concurrency models. Functional paradigms. Strong abstractions. Mental expansion through controlled suffering.

Alongside all of this, I want to keep following the thing that made me love engineering in the first place:

Game development.

At least two days every week will be reserved for building games, experimenting, and creating weird little worlds that may never ship but will keep the spark alive. I do not want this journey to become pure optimization and infrastructure grayness. A machine without creativity eventually becomes a factory.

This entire roadmap is going to take years.

And honestly, that’s fine.

For the first time in a long while, I’m not chasing shortcuts anymore.

I’m chasing competence.

My short-term goal is to land a DevOps role. My long-term goal is to become a system architect capable of designing reliable, scalable, and secure systems from the ground up.

And to keep myself accountable, I’m going to document the journey publicly through weekly posts. Progress, failures, discoveries, frustrations, all of it.

Maybe this series will help someone else who feels stuck in the same cycle.

Maybe it will simply become a record of one engineer rebuilding his foundations one layer at a time.

Either way, this is the start of something new.

The terminal is open.
The cursor is blinking.
And this time, I actually want to understand what I’m typing