mika's open learning notebook

notes on programming, linux, software, and whatever i'm learning


Career · September 30, 2026

September 30, 2026 — From Self-Taught Builder to Hireable Engineer

A research-informed roadmap for turning practical self-taught development experience into stronger fundamentals, production depth, interview readiness, and clear hiring evidence.

I do not need to restart from zero.

I already know how to build software. The next stage is turning practical ability into clear, repeatable, interview-ready engineering skill.

This roadmap is my default plan until evidence tells me to change it.

The goal is not to collect more technologies, courses, or repositories.

The goal is to become easier to evaluate and easier to hire.

The core strategy

My primary lane is software engineering.

My differentiator and secondary lane is technical writing and developer documentation.

The rough allocation is 70% engineering, 20% technical writing, and 10% job-search mechanics.

The central idea is:

Build depth where I already have breadth.

I have already built across web development, Python, Linux, desktop apps, APIs, AI tooling, agents, documentation, open source, and client work.

The next step is not adding another pile of technologies. It is strengthening the fundamentals underneath that work and proving that I can build, test, deploy, explain, and maintain software professionally.

Phase 0 — immediate opportunities first

When an active interview, coding challenge, or take-home exists, it takes priority over the long-term curriculum.

For coding assessments, focus on:

  • arrays and lists
  • dictionaries and hash maps
  • sets
  • strings
  • loops and conditionals
  • functions
  • sorting and filtering
  • basic time and space complexity
  • SQL
  • Bash and Linux fundamentals

The roadmap supports opportunities. It should never become an excuse to delay applying.

Phase 1 — computer-science foundations

Use CS50x as the backbone for filling formal CS gaps.

Prioritize:

  1. C fundamentals
  2. arrays
  3. algorithms
  4. memory
  5. data structures
  6. Python
  7. SQL

Do the problem sets. Watching lectures is not enough.

The purpose of this phase is to attach names and mental models to concepts I often already use in practice.

Exit criteria

I should be able to explain, in my own words:

  • stack vs. heap
  • arrays vs. linked lists
  • hash tables
  • stacks and queues
  • recursion
  • binary search
  • Big-O notation
  • pointers and references conceptually
  • processes vs. threads at a basic level
  • HTTP requests and responses
  • DNS
  • REST APIs
  • relational databases
  • indexes
  • transactions
  • SQL joins
  • Git branches
  • Linux files, processes, and permissions

I do not need academic mastery. I need enough understanding that common interview questions no longer feel like unfamiliar vocabulary for things I already use.

Phase 2 — deepen one professional stack

My primary professional stack is:

TypeScript → React → Next.js → Node.js → PostgreSQL

My second language is Python.

Python remains especially useful for automation, backend work, tooling, AI systems, and coding assessments.

The rule for this phase is:

Do not add another language or framework unless a real project or job requires it.

Breadth is no longer the bottleneck. Depth is.

Phase 3 — become production competent

Stop measuring progress with only:

Can I build the feature?

Start measuring it with:

Can I build, test, deploy, observe, debug, secure, document, and maintain the feature?

Take one existing application and give it professional treatment.

It should include as many of these as are appropriate:

  • clear architecture
  • TypeScript where relevant
  • PostgreSQL
  • migrations
  • authentication
  • input validation
  • error handling
  • structured logging
  • unit tests
  • integration tests
  • end-to-end tests
  • GitHub Actions CI
  • Docker
  • environment configuration
  • secret management
  • accessibility review
  • deployed production environment
  • strong README
  • architecture diagram
  • API documentation
  • issue tracking
  • release notes

This phase matters more than starting another unrelated portfolio project.

Phase 4 — DSA without turning into a LeetCode monk

Algorithm interviews are imperfect, but they remain part of hiring.

Practice roughly three problems per week.

Study in this order:

arrays and strings → hash maps → sets → two pointers → sliding window → stacks and queues → binary search → linked lists → trees → BFS and DFS → basic dynamic programming

For every problem, practice explaining:

  1. the brute-force approach
  2. the improved approach
  3. why the data structure was chosen
  4. time complexity
  5. space complexity

The target is not hundreds of memorized solutions. The target is a smaller set of patterns I understand deeply enough to reproduce under pressure.

Phase 5 — learn AI engineering rather than only AI-assisted coding

Using an LLM to generate code is not the same thing as engineering a system that contains an LLM.

Build competence in:

  • model APIs
  • structured outputs
  • tool and function calling
  • embeddings
  • retrieval and RAG
  • evaluation
  • prompt injection
  • context management
  • token and cost management
  • retries
  • failure handling
  • observability
  • testing around nondeterministic components

The preferred positioning is:

Software engineer who can build AI-enabled systems.

The goal is not to rely on AI more. The goal is to understand where AI belongs, where it fails, and how to evaluate it.

Phase 6 — junior-level system design

Do not study distributed-systems interviews meant for staff engineers.

Practice small systems such as:

  • URL shortener
  • notification service
  • review-request system
  • simple inventory application
  • webhook processor
  • small content platform

Understand:

  • client and server boundaries
  • API design
  • database selection
  • indexes
  • caching
  • queues
  • authentication
  • rate limiting
  • idempotency
  • consistency
  • failure modes
  • horizontal vs. vertical scaling

The practical goal is being able to explain why I designed my own software the way I did.

Phase 7 — keep technical writing as an engineering advantage

Do not position technical writing as merely “writing well.”

The stronger position is:

I can understand the system deeply enough to explain it accurately.

Maintain a portfolio that includes:

  • API reference
  • getting-started tutorial
  • installation or deployment guide
  • troubleshooting guide
  • architecture overview
  • README
  • migration guide
  • technical article

This supports software-engineering roles while also keeping paths open to technical writing, developer documentation, documentation engineering, programmer writing, developer education, and developer relations.

Portfolio strategy — fewer projects, more evidence

Do not present every repository as equally important.

Keep roughly three flagship projects.

1. Real-world or client software

Demonstrate:

business requirement → implementation → integration → deployment → real user or client handoff

2. Open-source engineering

Demonstrate:

architecture → testing → releases → contributors → documentation → community usage

3. Technically ambitious engineering

Choose based on the role:

  • AI, platform, or backend work for AI-oriented jobs
  • full-stack or visual work for frontend and product-oriented jobs

Everything else is supporting evidence.

The hiring goal is not “look how many repositories I have.”

It is “I know how to build software.”

Weekly operating rhythm

A normal week can look roughly like:

Area Weekly time
CS fundamentals / CS50 5 hrs
Production engineering 5 hrs
DSA / assessments 3 hrs
Existing project work 4 hrs
Technical writing 3 hrs
Applications / networking 4 hrs
Reading docs / exploration 2 hrs

That is about 26 focused hours, not an endless grind.

Several hours each week should happen without an AI system writing the solution.

AI should make me faster. It should not hide whether I understand the fundamentals.

Interview-readiness checklist

Programming

  • Why this data structure?
  • What is the complexity?
  • What is mutable vs. immutable?
  • What happens in memory?

Web

  • What happens when I enter a URL?
  • How does HTTP work?
  • What is REST?
  • What is CORS?
  • Cookies vs. tokens?

Databases

  • joins
  • indexes
  • normalization
  • transactions
  • schema design

Engineering

  • Git
  • CI/CD
  • Docker
  • testing
  • logging
  • debugging
  • secrets
  • basic cloud deployment

Architecture

  • Explain one system end to end.
  • What would break at 100× traffic?
  • What would I redesign?

AI

  • What should an LLM handle?
  • What should it not handle?
  • How do I evaluate outputs?
  • How do I design for failures?

Professional experience

  • Tell me about a bug I diagnosed.
  • Tell me about a design decision I changed.
  • Tell me about conflicting requirements.
  • Tell me about software I shipped.

The requirement is not perfect answers. It is truthful, technically grounded answers without bluffing.

Anti-roadmap: what not to do

Avoid this loop:

course → certificate → course → certificate → tutorial → new framework → new project → another framework → still feeling unqualified

A course is useful when it closes a known gap.

A certificate is useful when it adds recognizable signal.

A project is useful when it demonstrates a capability that is currently missing.

Otherwise, it is probably distraction disguised as progress.

The roadmap in one line

CS50 → DSA / SQL / Linux fundamentals → deepen TypeScript / React / Node / PostgreSQL → Python / AI → testing / CI / Docker / cloud → junior system design → three polished flagship projects → interview practice + consistent applications.

How I will know the roadmap is working

I should see evidence in:

  • stronger assessment performance
  • fewer concepts that I use but cannot explain
  • deeper project documentation
  • better tests and release practices
  • more confident technical interviews
  • portfolio projects that are easier to evaluate
  • job applications that map directly to demonstrated skills

This is a living plan.

I can change it when interviews, job descriptions, project failures, or new evidence reveal a more important gap.

But I should not change it merely because a new technology looks interesting.

Research behind the plan

Useful references:

Main principle

I do not need to become a different kind of developer. I need to make the developer I already am deeper, more explainable, and easier to hire.