czay.devJunior Frontend Developer 2026
Junior frontend job posts in Turkey keep piling Docker, CI/CD, GraphQL and Cloud on top of React. This roadmap sorts through that list: the foundation you really need to get hired, the things that show up in posts a lot but aren't required, and the things you'll learn once you're on the job.
Knowing 20 technologies on the surface isn't worth more than knowing none of them properly. Go in order, click each topic to see what you need to know, and check off what you've learned.
- CoreKnow this well before you apply
- Nice to haveShows up a lot in job posts, gives you an edge
- LaterOnce you're on the job, when you need it
Click a topic to see what you need to know and where to learn it.
- 01
Foundations
What everything else is built on. Skip it, and you'll keep coming back to it at every stage after.
- 02
Tools
The everyday tools you need to work on a team.
- 03
Framework
The part job posts are really asking for. If your foundation is solid, this goes faster than you'd think.
- 04
Getting job-ready
Things that show up a lot in job posts and set you apart from other candidates.
- 05
Things you can learn later
Things you see in job posts but don't need to get hired. You'll learn them in production, as the need comes up, together with your team.
Topic by topic
Every topic on the map with its description, what to know and resources — in one list.
01Foundations
How does the web work?· Core
Knowing what happens when you type an address into the browser helps you make sense of half the errors you'll run into. You don't need depth here — the big picture is enough.
What you should know
- The client–server model: a request goes out, a response comes back
- Roughly what a domain name, DNS and hosting are
- How the browser takes HTML, CSS and JavaScript and draws them on screen
Resources
HTTP and HTTPS· Core
The language the frontend speaks. If you can read methods and status codes, you can debug API errors on your own.
What you should know
- When to use GET, POST, PUT, PATCH and DELETE
- Status codes: 200, 201, 301, 400, 401, 403, 404, 500
- Request and response headers
- Why HTTPS is a must
Resources
DNS and domain names· Core
How a domain name gets resolved to a server. The first thing you'll run into when you put your project online.
Resources
The browser and rendering· Core
The path from HTML to the DOM, and from CSS to pixels on the screen. Whenever performance comes up, everyone ends up back here.
What you should know
- The DOM and the CSSOM
- Layout, paint, composite
- Render-blocking resources
Resources
HTML· Core
The skeleton of the page. People skip it because 'HTML is easy', yet it's the topic that exposes the most gaps in interviews: picking the right tag decides both accessibility and SEO.
What you should know
- Document structure: head, body, meta tags
- Picking the right tag: div isn't the answer to everything
Resources
Semantic HTML· Core
header, nav, main, article, section, button — each one means something. Screen readers and search engines both read that meaning.
What you should know
- If you click it, it's a button; if it takes you somewhere, it's an a
- Heading order: h1 → h2 → h3
- Landmark elements
Resources
Forms· Core
You'll write these at almost every job. label, input types and the browser's built-in validation save you from writing a lot of JavaScript.
What you should know
- Connecting a label to its input
- Input types: email, number, date…
- required, pattern, min/max
Resources
Accessibility· Core
A page you can get around with a keyboard and read with a screen reader. Nobody expects a junior to be an expert, but they do expect the basics.
What you should know
- Alt text
- Keyboard focus order
- Color contrast
- Using aria only when you actually need it
Resources
SEO basics· Nice to have
title, description, heading structure and meaningful URLs. If you're writing semantic HTML properly, you're already halfway there.
Resources
CSS· Core
Turning a design into code. Even if you use Tailwind, there's CSS underneath — if you don't get the box model and layout, you'll get stuck in Tailwind too.
What you should know
- Selectors and specificity
- Units: px, rem, %, vw
- Inheritance and the cascade
Resources
Box model· Core
Every element is a box: content, padding, border, margin. Most layout bugs come from here.
What you should know
- box-sizing: border-box
- Margin collapsing
- display: block, inline, inline-block
Resources
Flexbox· Core
Alignment along one axis. Most of the layouts you'll write today are flexbox.
Resources
Grid· Core
Layout on two axes. For card grids and page skeletons it's much simpler than flexbox.
Resources
Responsive design· Core
The same page, from a phone to a wide screen. Writing mobile-first isn't a preference anymore — it's the default.
What you should know
- Media queries
- The mobile-first approach
- Flexible units and clamp()
Resources
Tailwind CSS· Nice to have
It's in most job posts, and if you know CSS you'll pick it up in a week. The order matters: CSS first, then Tailwind.
Resources
JavaScript· Core
The most important stop on the map. Most people who get stuck in React are really stuck in JavaScript. Don't rush this one.
What you should know
- Variables, types, functions
- Conditionals and loops
- Objects and arrays
Resources
Modern syntax· Core
Things you'll see on every line of React code. If you can't read these comfortably, React is going to feel hard.
What you should know
- let / const, arrow functions
- Destructuring and spread
- Template literals
- Optional chaining (?.) and ??
Resources
Array methods· Core
map, filter, reduce, find. This is how you render lists and reshape data in React.
Resources
The DOM and events· Core
React does this for you — but you should do it by hand first, so you understand what React is actually solving.
What you should know
- Selecting and changing elements
- addEventListener
- Event bubbling and delegation
Resources
Async JavaScript· Core
Fetching data, waiting for it, catching errors. Interviewers' favorite topic.
What you should know
- Callback → Promise → async/await
- Fetching data with fetch
- Handling errors with try/catch
- Roughly what the event loop is
Resources
Scope and closures· Core
Modules· Core
import / export. This is how the files in every modern project connect to each other.
Resources
02Tools
Git and GitHub· Core
You'll use it on day one. Saving your code, creating branches, merging and sharing with your team. Your portfolio lives here too.
Resources
Commits and history· Core
add, commit, status, log, diff. Making small commits that each mean something.
Resources
Branching and merging· Core
Creating branches, merging them and resolving conflicts. Not being scared of conflicts is a skill in itself.
Resources
Pull requests· Core
This is how code gets merged on a team. Opening a PR, writing a description and responding to review comments.
Resources
Dev environment· Core
The tools you use to set up a project, run it and track down bugs.
npm / pnpm· Core
Installing packages, reading package.json, running scripts.
What you should know
- The difference between dependencies and devDependencies
- npm run dev / build
- Why the lock file exists
Resources
Vite· Core
Today's default way to start a React project. Knowing roughly what a build tool does is enough.
Resources
Browser DevTools· Core
ESLint and Prettier· Nice to have
Letting a tool settle the code-style arguments. Most projects come with them already set up — knowing what they're for is enough.
Resources
03Framework
React· Core
It's in nearly every junior frontend job post in Turkey. The official docs on react.dev are worth reading cover to cover.
Resources
Components and JSX· Core
Breaking the UI into small, reusable pieces.
What you should know
- The rules of JSX
- Passing data with props
- Conditional rendering and lists (key)
Resources
State and events· Core
Interactivity with useState. The real skill is deciding where a piece of state should live.
What you should know
- useState
- Lifting state up
- Controlled form inputs
Resources
Effects· Core
When you need useEffect — and, more importantly, when you don't.
Resources
Other hooks· Core
useRef, useMemo, useContext, and writing your own hooks.
Resources
Routing· Core
Apps with more than one page. React Router, or your framework's own routing.
Resources
Global state· Nice to have
Context is enough most of the time. If you see Zustand or Redux in a job post, understand the idea; no need to memorize the API.
Resources
TypeScript· Core
It's in almost every job post now, and most new projects start with TypeScript. Nobody expects advanced type gymnastics — everyday use is what counts.
Resources
Basic types· Core
type and interface· Core
Describing the shape of your data. Being able to write a type for the response an API sends back.
Resources
TypeScript with React· Core
Prop types, state types, event types. That's most of the day-to-day work.
Resources
Generics· Nice to have
Being able to read them is enough. Nobody expects a junior to write their own generic types.
Resources
Working with APIs· Core
Most of frontend work is showing data that comes from an API and sending data back. Not writing the backend — talking to it.
REST and JSON· Core
Endpoints, methods, request bodies, JSON responses. Poking at an API with Postman or a similar tool.
Resources
Loading and errors· Core
What do you show while the data is on its way, and what happens when an error comes back? The part junior projects skip the most.
What you should know
- Loading, error and empty states
- Cancelling a request
- Error messages that actually mean something to the user
TanStack Query· Nice to have
Handles data fetching, caching and retries for you. Shows up a lot in job posts.
Resources
How authentication works· Nice to have
What a token is, what a cookie is, how you can tell a user is logged in. Not building it — understanding it from the frontend side.
Resources
04Getting job-ready
Next.js· Nice to have
Learn it after React, not before. It's in a good share of job posts; understanding why server-side rendering exists is a good enough start.
Resources
File-based routing· Nice to have
SSR, SSG, CSR· Nice to have
Where and when a page gets generated. Knowing the concepts goes a long way in interviews.
Resources
Testing· Nice to have
Nobody expects a junior to have a testing strategy; they do expect you to write a simple component test and know why tests get written.
Vitest· Nice to have
Testing Library· Nice to have
A real project· Core
I'd rather see a junior who can explain why they picked each technology in one real project than a CV listing 15 frameworks. This is where the whole roadmap is taking you.
What you should know
- Not a todo app — a project that solves a real problem
- One that pulls data from a real API and handles loading and error states
- One that looks right on mobile and works with a keyboard
Deploying· Core
If your project doesn't open at a URL, it might as well not exist. With Vercel, Netlify or Cloudflare Pages it takes a few minutes.
Resources
README· Core
What the project does, how to run it, and why you made the decisions you made. The first file a recruiter reads — and often the only one.
Explaining your decisions· Core
“Why Zustand?”, “Why this folder structure?” What an interview is really measuring is how you answer questions like these.
05Things you can learn later
How the backend works· Later
Understanding the backend is really useful for a frontend developer. But writing APIs and setting up databases and authentication is a full-stack job.
Node.js· Later
Writing a simple API and hooking your frontend up to it will open your eyes. Not required for a junior frontend role.
Resources
GraphQL· Later
If your company uses it, you'll learn it in a week. Knowing REST comes first.
Resources
Infrastructure· Later
There's usually someone on the team who sets this up. What's expected of you is being able to use what's already there.
Docker· Later
Running a project in a container. Being able to read an existing Dockerfile is enough to start with.
Resources
CI/CD· Later
Tests running on every push, a deploy on every merge. At your first job you'll find it already set up.
Resources
Cloud· Later
AWS, GCP, Azure. For frontend, it usually comes down to a CDN and static hosting.
Architecture· Later
Architecture, scalability, code review, mentoring. These come with experience; if you see them in a junior job post, something's probably gotten mixed up.
Scalability· Later
Keeping a growing codebase manageable. You need to have worked in a big codebase first.
Advanced performance· Later
Core Web Vitals, bundle analysis, render optimization. Basic performance common sense is enough — you'll learn the rest on the job.
Resources