Developer roadmaps for CSE and engineering students in India Free phased learning paths for campus placements and internships — DSA, full stack, frontend, backend, AI/ML, data, cloud, DevOps, security, mobile, UX, product, and QA. Each track uses checkboxes, project guides, and optional Coder AI help on Underrated Coder.
All career tracks AI & ML — Start with Python, then simple models. Backend Developer — Start with a small server, then a database. Blockchain & Web3 — Start with how a chain works, then one small app. Cloud Computing — Start with one AWS account, then a small setup. Cybersecurity — Start with networks, then how to keep apps safe. Data Analyst — Start with spreadsheets, then SQL and a dashboard. Data Engineer — Start with SQL, then a data pipeline you can rerun. Data Science — Start with Python and SQL, then one model. DevOps — Start with Linux, then Docker and safe releases. DSA — Start with easy Java, then coding problems. Frontend Developer — Start with HTML and CSS, then React. Full Stack Developer — Start with a web page, then a full app. Mobile App Developer — Start with JavaScript, then a simple phone app. Product Manager — Start with user problems, then a simple plan. QA Engineer — Start with what to test, then automate one flow. UX Design — Start by looking at screens, then test a design. An easy path into machine learning. Start with Python and clean data, then one simple model at a time, then a small app. You do not start with hard models.
Phase 1: Easy start — Python you can trust Install Python 3 and run a script in its own environment Write functions, lists, dictionaries, and loops Read and write a CSV file Handle a missing value without crashing the script Put the project in Git and ignore the virtual environment folder Write three lines that explain what the script prints Phase 2: Next step — clean the data before any model Load a table and print how many rows it has and what type each column is Pick rows and columns in a clear way, not with a chain of guesses Fill or remove missing values, and write down which you chose Join two tables on a shared key Do a number calculation on a whole column at once Draw a bar-style distribution and a scatter plot that answer a question Write five things you notice from the plots before you train anything Split practice data and test data before you train, and never train on the test rows Phase 3: Next step — math you will actually use Compute the average, the middle value, and the spread on a tiny dataset Plot a line and name the slope and where it crosses the axis Add two number lists and compute a dot product by hand, then in code Multiply a small table of numbers by a list and say what changed Describe a derivative as a slope you can walk down Explain the chance of A and B versus the chance of A when you already know B Explain Bayes' rule in words with a medical-test example Phase 4: Build on that — one simple model at a time Fit a straight-line model and read what each input does to the result Fit a model that answers yes or no Fit a decision tree and limit how deep it is so it cannot memorize the data Fit a group of trees and compare it with the single tree Group similar rows and explain why you chose that number of groups Shrink many columns into fewer ones, and say what the first new column captures Use a pipeline so data cleanup cannot leak into the test set Phase 5: Build on that — scores, and how models can mislead you Report how often the model is right, and how well it finds the cases you care about Explain why 'percent correct' is a bad headline when one answer is much more common Plot a grid of right and wrong answers and name the costly mistake Test the model on several splits and report the range, not one lucky score Find one leak, such as a column that already contains the answer Write the decision a business would make from the score Phase 6: Harder practice — a small neural network Build a small neural network with one hidden layer Train it and plot how the error falls Explain overfitting: the practice error falls while the check error rises Add a simple guard against memorizing, and compare the check error Run a ready-made image or text model and read its output Save the trained numbers and load them in a new run Phase 7: Harder practice — language-model apps companies hire for Call a language model with a question, a system instruction, and a creativity setting Put the user's text in a clearly marked section so your instructions stay separate Split a document into pieces and turn each piece into a numeric fingerprint Find the pieces that best match a question Answer from those pieces, and say you do not know when they do not contain the answer Score 20 questions by hand: correct, incomplete, or not supported by the text Let the model call one tool, such as a database lookup, and check the arguments Save the question, the pieces you found, and the answer so you can debug a bad reply Phase 8: Get ready — a demo, a resume, and interviews Put one model, or a lookup-then-answer flow, behind a small web API Add a simple page where someone else can try it Put it on a link that stays up for a week Write a README with the data, the score, and one known failure Prepare a ten-minute story: the problem, the data, the score, and what failed Solve 15 coding problems. Many ML internships still start with a coding test Do one practice interview about a score, a data leak, and your demo Apply with the link and the notebook or repo An easy path after JavaScript. Learn how a blockchain works, then Solidity, tests, and one small app on a test network.
Phase 1: Easy start — JavaScript, then how a chain works Explain a block as an ordered batch of transactions that includes a fingerprint of the previous block Explain a public address and a private key, and what you must never paste into chat Explain gas as the fee, and the limit on how much work a transaction may do Explain proof of stake versus proof of work by who gets to add the next block Write TypeScript functions and async calls. The app in front of a contract is still a web app Put a project on GitHub before you touch a wallet Create a wallet on a test network and save the recovery phrase offline Read a transaction on a block explorer and name who sent it, who received it, and the status Phase 2: Next step — Solidity, one idea at a time Write a contract, one saved value, and one function Separate a function that only reads from one that changes saved data Use a lookup and a small record for one real thing, such as a balance Limit who can call a function Record an event when saved data changes Send and receive the smallest money unit on purpose, and name that unit Explain why a decimal float is the wrong type for money Compile with the Solidity version fixed in your project settings Phase 3: Build on that — Foundry tests Install Foundry and run the default test Write a test that the normal success path changes the saved data Write a test that a caller who is not allowed is rejected Write a test that zero, or a number that is too big, is rejected Print the fee used by the function you care about Run the tests automatically on every push Phase 4: Harder practice — habits that keep a contract easy to review Update your saved data before you call outside code in a withdraw function Write a test that a second caller cannot take the money after a withdraw Limit admin functions to allowed people, and test that someone else is rejected Get prices from a trusted price source, and write why a price the contract invents is unsafe Pause or limit a function and test that the limit holds Read one public security review and summarize three findings in your own words Phase 5: Harder practice — a small app on a test network Deploy the contract to a test network and save the address Show the source code on the block explorer Connect a React or Next.js page to the contract with a maintained Ethereum library Connect a wallet and show the connected address Call a function that changes data, and wait for the receipt before you update the page Show a failure when the user says no, or when the call fails Write how a reviewer gets test-network money and runs the app Phase 6: Get ready — jobs, and what companies actually hire for Write a README a backend student can follow without knowing the jargon Record a three-minute demo of the test and the page Also finish one normal web or backend project. Most software jobs hire for that Keep doing the DSA roadmap if you will also take campus coding tests Prepare to explain a test, a permission check, and a failed transaction Apply to internships that mention Solidity, with the demo linked An easy path through AWS. Start with the account and a billing alarm, then a simple page, a server, and a small app. Practice comes before any exam.
Phase 1: Easy start — the account, before any service Create an AWS account and turn on a billing alarm Turn on a second login check for the root user, then stop using root Create your own admin user and sign in as that user, not as root Create a read-only user and confirm it cannot create a server Set a budget alert at a small student amount Name the region you will use and stick to it for the lab Phase 2: Easy practice — one page, using the simple defaults Start a free-tier server with the simple wizard and open a page Stop that server and write down what still costs money Phase 3: Next step — networking you can see Create a private network with one public section and one private section Connect the public section to the internet and add a route Explain a private address versus a public address using your own setup Create a firewall rule that allows only the port you need Explain a network access list as a broader rule for a section, then leave the default unless you need it Draw the path of a request from the internet to your server Phase 4: Build on that — a server in the network you built Start a server in the public section and connect to it Install a tiny web server and open it in your browser Stop the server when you are done, and note that storage may still cost money Create a storage bucket that blocks public access Upload a file and read it back from the terminal Add a bucket rule only if you can explain who it allows Turn on a cleanup rule, or write why this practice bucket does not need one Phase 5: Build on that — data and a small function Create a free-tier database in the private section Connect from a tool you are allowed to use and run one SQL query Store the password in a secrets tool, not in a screenshot Write a small cloud function that returns JSON Run it from the console and read the log Give the function permission to do one thing, not full admin access Phase 6: Next step — watch it, and see what it costs Find the server or function log and read one error Name one number you would want an alert for Open the bill and point at the service that cost money Delete or stop every practice resource you do not need this week Write a cleanup checklist in the README Phase 7: Harder practice — describe the same setup in code Install the AWS command line and run one read-only command as your own user Describe one cloud resource in Terraform Preview the change, apply it, then delete it Save the Terraform files in Git, and do not save keys Explain state: what it remembers, and why you do not edit it by hand Phase 8: Get ready — one app, then decide on a certificate Deploy a small app you wrote: a server, locked-down storage or a database, and a link Match the same idea to one Azure or Google Cloud name, so another job post is readable List the AWS services you used, in your own words Only then start the beginner cloud practice exams When you miss a practice question, do the task in the console before you reread the slide Phase 9: Get ready — cloud interviews Explain users and permissions, your private network, and a firewall rule without a diagram Explain how you would keep a student project from surprising you on the bill Walk through your live app and how you clean it up Solve 15 coding problems if the job also has a coding test Write one resume line about the setup, not a list of every service logo Apply with the diagram and the repo An easy path into security jobs. Start with computers and networks, then Linux logs and web safety. Only practice on systems you are allowed to test.
Phase 1: Easy start — computers and networks Turn on the disk or account protection you already have, and know what it does Read a web request: the method, the headers, and the status Explain three security goals with a campus example: keep it private, keep it correct, and keep it available Draw the path of a message from your laptop to a website Explain TCP versus UDP in simple words Explain DNS, and what breaks if the name lookup is wrong Explain a running program, a user account, and a file permission on a computer you use Phase 2: Next step — Linux and logs Create a normal user, not an admin, and use it for daily practice Read login logs and list failed sign-in attempts Find which program is listening on a port Compare a file's fingerprint before and after you edit it Write a shell note of commands you ran in the lab Explain 'only the access you need' using the user you created Phase 3: Build on that — web safety, one control at a time Write how you would stop someone from opening another person's item by changing the id Explain why a query with placeholders stops someone from sneaking in extra SQL Make sure the page shows user text as text, not as code List the cookie safety flags you want on a login cookie Explain a trick where the browser sends a login cookie the user did not mean to send, and one way to stop it Turn on HTTPS for a practice app and know what the certificate is for Add one security header and check that it comes back in the reply Read a common web-risks list and write, in your own words, how you would prevent each one you have not covered Phase 4: Build on that — who can sign in, and cloud safety Turn on a second login check on your email and your cloud practice account Create a cloud user with one permission and test that a second permission is denied Remove a key you no longer need Explain a public storage bucket or public database as a mistake, and lock yours down Read an activity log and say who did what Write who gets access when they join, what changes if their role changes, and when access ends Phase 5: Harder practice — spotting problems and writing a short note Pick one log and write three events you would want an alert for Look at a sample alert: what you know, what you do not, and what you would ask Build a timeline from the times in a sample log Write a short incident note a manager can read in five minutes Explain the difference between a weakness, a wrong setting, and a real incident Remember the rule: you only test systems you own or have written permission to test Phase 6: Harder practice — safe coding habits Scramble a password in a demo and keep the scrambled value, not the password Check input on the server even if the form already checked it Run a check for risky packages and upgrade one package it flags Remove a password from a repo and change that password Review a classmate's change and look for one missing permission check Write a short threat note: what you are protecting, how it could be misused, and what you added to stop that Phase 7: Get ready — a security resume and the interview Publish a write-up of a lab you own: what was weak, what you changed, and how you checked Prepare one answer about watching alerts, and one about keeping an app safe Practice aptitude during placement season. Many security tests still include it Solve 15 coding problems if you are also applying to software jobs Write one resume line about the safety check you added, not a list of tool logos Apply to junior security internships with the write-up An easy path into analyst jobs. Start with spreadsheets, then SQL, then a dashboard a manager can use. The math stays light. Follow the phases in order.
Phase 1: Easy start — spreadsheets Type ten rows into a blank sheet, sort them, and make one chart Clean a messy sheet: fix types, blanks, and duplicate rows Look up a value from another table Build a summary table with one row group and one number Add a second grouping and explain the new total Chart the result and title the chart with the conclusion Use a repeatable cleanup step so you do not clean the sheet by hand next time Protect the raw tab and do the analysis on a copy Phase 2: Next step — SQL Pick columns and filter rows Sort and keep only the rows someone asked for Count and add totals by group Keep only the groups that pass a test Join orders to customers and keep only the matches Keep customers who have no orders Write a query inside another query Rewrite that inner query as a named step you can read from top to bottom Rank rows without collapsing them into one group Compare each row with the previous or next row Phase 3: Build on that — numbers you can explain Choose the average or the middle value, and say why, when the numbers lean to one side Compute a rate and write what is on the top and what is on the bottom Explain a change in percentage points versus a percent change Write what you expect before you compare two groups Name a hidden factor that could explain a jump in a number Write the limit under the chart, not only the headline Phase 4: Build on that — a dashboard in Power BI Load a CSV or a database into Power BI Link tables instead of pasting everything into one flat table Write one calculated number for a business metric Build a page with a filter a manager would actually use Check that the total still makes sense after filtering Remove a chart that does not change a decision Publish the report and open it as a viewer Phase 5: Next step — Python when the sheet is not enough Load the same data in Python Repeat one SQL total in Python and check that the numbers match Clean a text column and a date column Draw one chart that the dashboard tool made hard Save the script so next month you can run it again instead of rewriting it Phase 6: Harder practice — one business case Pick a public dataset and write the decision it could support Define the number you will watch in one sentence Share a one-page note plus the dashboard or sheet Record a five-minute walkthrough Ask someone who is not technical what they would do next, and note the gap Use an assistant to draft the words, then recompute every number yourself Phase 7: Get ready — analyst interviews and applications Solve two timed SQL tests Answer a case: a number moved, what do you check first Walk through your dashboard without describing every click Do one aptitude set a week during placement season Write one resume line with the number and the tool Apply with the note and the report link An easy path into data engineering. Start with Python and SQL, then a warehouse, a scheduled job, and checks that the data is right.
Phase 1: Easy start — Python, Linux, and Git Move, search, and edit files from the terminal Write a Python script that reads a file and writes a cleaned file Do not schedule it yet. Run the script on purpose and write down the result Save the script and a sample file that contains no private data Lock the library versions so a classmate can run it again Phase 2: Next step — SQL and simple data models Pick rows from one table with a filter Join two tables and keep only the matching rows Name a query step and select from that name Rank rows without collapsing them into one total Read a query plan and point at a full table read Separate a table the app writes from a table used for reports Design a simple report layout: one facts table and at least two lookup tables Say what one row in the facts table means, in one sentence Choose a main key that still works if you load the data again Write down one value that changes over time, and how you would keep the history Phase 3: Build on that — a warehouse and dbt Create a free data warehouse project, or use one your college account allows Load a raw CSV into a raw dataset Create a dbt project that reads from that raw table Build a cleanup step that renames columns and sets their types Build the final report table at the row meaning you wrote down Add a test that the main key is unique and not empty Run the project and query the final table with SQL Save the dbt project in Git, not your passwords Phase 4: Build on that — run it on a schedule Explain copy the data in first, then clean it, and why that fits a warehouse Put the dbt run on a schedule you can show Make a second run safe so you do not copy the same day twice Alert yourself when a test fails Fill in one past day and show the row counts Write in the README how to run it again, and who to tell Phase 5: Harder practice — Spark when one query is not enough Explain splitting data so a job reads less of it Read a Parquet file, not only a CSV Run a Spark job that totals a dataset too big for a laptop sheet Write the output as a Parquet file Say when you would keep the job in the warehouse because it costs less Phase 6: Harder practice — quality, cost, and streaming as an idea Check that the row counts from raw data to the final table make sense Add one business check, such as amounts are not negative Read the bill, or the bytes a dry run would scan, and name the expensive query Split or cluster one large table and say which filter it helps Explain a stream as events you handle as they arrive, and name one tool a job post might list Draw a scheduled batch versus a live stream for the same number, and pick one for your project Phase 7: Get ready — interviews and a pipeline you can show Show the pipeline: raw file, cleanup, test, and a query on the final table Explain what one row means, the schedule, and one failure you handled Answer a SQL question live Solve 15 coding problems for the coding test Write one resume line with the warehouse, dbt, and the check you added Apply with the repo and a diagram of the pipeline An easy path into data science. Start with Python and SQL, then statistics, charts, and one model you can explain. Each checkbox is one small step.
Phase 1: Easy start — Python and SQL Run Python in its own environment and save the project in Git Load a CSV and check the rows, the types, and the missing values Filter, group, and join tables in Python Write a SQL SELECT that filters and sorts Write a SQL JOIN between two tables Group rows and compute a total or a count Save a chart as an image you can paste into a report Phase 2: Next step — statistics for decisions Compute the average, the middle, and the spread, and say when each one misleads Read a distribution chart and say if it leans left or right Explain a sample versus the full group you wish you had Write the 'nothing changed' idea for a question you care about Compare two groups and explain the p-value without treating it as magic Explain a confidence range in one sentence a manager can use Name one hidden factor that could fake a result Phase 3: Build on that — look at the data before a model Write the question in one sentence before you open the file Check missing values and duplicate rows Plot the answer against two columns you think matter Check a category column for a rare value that will break a split Write five findings, each tied to a chart or a table Fix one data bug and write it in the README Phase 4: Build on that — models and honest scores Split practice data and test data before you train Fit a simple first model so later models have something to beat Fit a tree model and compare it with the simple first model Report the score the decision needs, not the score that looks best Show where the model was right or wrong, or how far its guesses were List three columns and a plain reason each might matter Try one stronger model only after the simple first model is written down Phase 5: Harder practice — experiments and how you explain them Design an A/B test: who you compare, which number you watch, and what 'better' means Explain why checking the result every hour can fake a win Write a one-page note: question, method, result, and the limit Present the note in under ten minutes without reading the slides Use a language model to draft the note, then check every number yourself Phase 6: Harder practice — a project someone else can run Lock the library versions so a classmate can rerun the notebook Put raw data, cleaning, and the model in an order you write down Produce a prediction, or a scored table, from a small script Write who this model will treat badly Record a five-minute video or write a short walkthrough Phase 7: Get ready — internship interviews Solve a take-home style case in one sitting and time yourself Answer a SQL question on a whiteboard or a blank editor Explain memorizing the data, a leaked answer, and a simple first model without notes Solve 15 coding problems for the coding test Write one resume line with the question, the score, and the link Apply to analyst and ML intern roles with the same project, told clearly An easy path to a backend job. Start with the terminal and a tiny server, then APIs, SQL, login, and a public link. Each checkbox is one small step.
Phase 1: Easy start — the computer and how the web talks Use the terminal to move around, read files, and run a script Install Node.js and Git and push a repo to GitHub Explain a request and a reply, including the method and the status code Call a public API from the terminal and read the JSON data Run a one-file server that answers hello in the browser Explain DNS in one minute: it looks up a name before the connection starts Explain a process versus a thread in words you can say in an interview Phase 2: Next step — TypeScript for server code Write functions, objects, and arrays in TypeScript Describe the shape of the data you send and the data you get back Handle errors with a clear check, not an empty catch that hides them Read settings from the environment and refuse to start if one is missing Split the code into files so one file is not the whole server Write a small test for a simple function, such as a price calculation Phase 3: Build on that — an API, one route at a time Start an Express app that responds on one port Add a GET route that returns JSON Add a POST route that checks the data and returns 400 when it is wrong Add PUT and DELETE routes for one resource Return 404, 401, and 500 on purpose, and say what each one means Put shared checks in one place so every route can use them Log method, path, and status for every request Write the routes down as a short API list another student can call Phase 4: Build on that — PostgreSQL, the database Install PostgreSQL and connect with a client Create tables with a main key and a key that links to another table Insert, update, delete, and select rows Filter with WHERE and sort with ORDER BY Join two tables and explain which rows stay in the result Group rows and then keep only the groups that pass a test Add an index and explain which search it makes faster Explain a transaction using a money transfer between two rows Read a query plan and spot when the database reads the whole table Phase 5: Build on that — Prisma and database changes Describe the same tables in a Prisma file Apply a database change and save those files in Git Read the database from a route using Prisma Return one page of rows instead of every row When a value that must be unique is repeated, return a clear error Phase 6: Harder practice — login and safety habits Scramble a password before you save it, and never store the plain password Create a login session or a short-lived token and send it safely Protect one route so people who are not logged in get 401 Check that a user can only edit their own row Explain cookies versus the Authorization header Describe sign-in with Google in plain words, without building every option Allow only your own website to call the API Limit how many login tries one person can make in a short time Phase 7: Harder practice — saved answers, slow work, and app shape Save one slow answer in Redis and set a time so it expires Explain when a cache makes a bug worse Move one slow task, such as sending email, out of the request Draw your app as one service plus a database, and say what stays inside Explain a waiting line for work, and say when you would add Kafka later List what you would measure before you split the app into many small services Phase 8: Get ready — Docker, tests on every push, and a public link Write a Dockerfile that runs your API Run the API and PostgreSQL together with Docker Compose Add a GitHub Actions workflow that runs tests on every push Put the API on a public link a recruiter can open Store passwords and keys on the host, not in Git Put a proxy in front of your server so people do not connect to it directly Open the live health check after a restart and confirm the app comes back Phase 9: Get ready — simple system design and interviews Design a link shortener on paper: the routes, the table, and one index Explain how you would save answers, and what data could become old Explain scaling as more copies of the app behind a load balancer Write one resume line with the live API, the database, and login Practice 20 coding problems so the coding test does not end the interview Do one backend practice interview: a route, a database query, and one way it can fail Apply to internships with the repo and the deployed URL An easy path into DevOps. Start with Linux and Git, then Docker, a test pipeline, one cloud deploy, and how to undo a bad release.
Phase 1: Easy start — Linux and Git Navigate, read, and edit files from the shell Send one command's output into another command, and also save it to a file Read permissions and change them on a script you own Find a process and stop the one you started Read the end of a log file while an app is running Clone, branch, commit, and open a pull request Tell Git to ignore passwords and build files Phase 2: Next step — Docker Run a public Docker image and open its port on your machine Write a Dockerfile for a small web app Build the image and run it the same way twice Pass a setting with an environment variable, not a password written in the file Run the app and its database together with Docker Compose Explain a Docker image versus a running container in two sentences Phase 3: Build on that — a pipeline that can fail the build Add a test command you can run without clicking around Run that test automatically on every push Make the check fail when the test fails Save installed packages so the next run is faster Build the container image in the workflow Show the green check on the pull request Phase 4: Build on that — one cloud, one service Create a cloud account and turn on a billing alert Put the app on one managed cloud service Open only the port the app needs Store the password in the cloud settings, not in the repo Open the public link after a new deploy Write down what it costs per month if you leave it running Phase 5: Harder practice — describe servers in code Install Terraform or OpenTofu and print the version Describe one cloud resource, such as a storage bucket or a server, in code Run plan and read what will change before you apply it Create it, then delete it so the lab does not keep charging you Save the code in Git, and know where the state file lives Phase 6: Harder practice — Kubernetes objects you can name Run a local cluster and start one Pod from a file Open it with a Service and reach it Run two copies of the same app with a Deployment Change the version and watch the copies update one by one Go back to the previous version Read why a Pod is not ready Phase 7: Harder practice — logs, numbers, and a bad release Read app logs that include a time and a request id Add one number you can watch: how many requests, or how many errors Put that number on a dashboard, or write the query that shows it Cause a failed deploy on purpose in a lab and undo it Write a short note: what broke, how you knew, and what you changed List the access you would remove when a teammate leaves Phase 8: Get ready — interviews and proof Draw the path from a git push to the running copy of the app Explain a health check and what happens when it fails Walk through your pipeline from a laptop screen share Solve 15 coding problems. Many platform teams still start with a coding test Write one resume line with the tool, the deploy, and how you undid a bad release Apply with the repo and the architecture sketch An easy path from your first Java program to placement tests. Start with small programs, then lists, text, trees, and graphs. Harder topics come later.
Phase 1: Easy start — set up Java and run a program Install Java (JDK 21) and run a program from the terminal Write variables, if/else, and for and while loops Write a function that takes inputs and gives one result back Store values in a fixed list and in a list that can grow Cut, search, and compare text with Java String methods Read numbers and text the way a coding test sends them Save a value by a name (HashMap) and save only unique values (HashSet) Read the error message and fix a null or wrong-position bug Upload this practice code to GitHub with a short README Phase 2: Easy practice — small programs you can finish today Print the numbers 1 through 10 and their sum Find the largest and the smallest number in an array you typed Count how many values in that array are even Check whether a number is prime Print a triangle of stars using nested loops Phase 3: Next step — how much time and memory your code uses Count the loops and say how the running time grows (Big O) Say how much extra memory your solution uses, besides the input Replace a slow nested loop with a faster HashMap lookup Say the simple slow idea out loud before you make it faster Phase 4: Lists of numbers (arrays) Reverse a list without making a second list Move zeroes to the end and keep the other values in order Find two positions whose numbers add up to a target Find the number that shows up more than half the time Merge two sorted arrays Move every item in a list k steps Sort a list of only 0s, 1s, and 2s in one loop Build running totals so you can answer the sum from here to there Find the continuous slice with the biggest sum (Kadane's algorithm) Find the continuous slice with the biggest product Phase 5: Text and counting how often things appear Check if a word reads the same forwards and backwards Check if two words use the same letters, by counting each letter Find the first character that does not repeat Find the longest piece of text with no repeated letter Group words that use the same letters Count how many times each number appears Find the number that appears once when every other number appears twice Phase 6: Next step — searching and sorting Search an unsorted list by checking one item at a time Search a sorted list by cutting it in half each time Use binary search to find the smallest value that still works Search a sorted list that was rotated Write insertion sort and say when it is good enough to use Implement merge sort Write the split step used by quick sort Sort your own objects using a rule you choose Solve 15 easy problems and name the pattern for each one Phase 7: Harder practice — a function that calls itself Draw how a Fibonacci function calls itself List every smaller group you can make from a small list List every order of a three-letter string Find groups of numbers that add up to a target, and undo bad guesses Place queens on a 4 by 4 board so no two can attack each other Stop a guess as soon as you know it cannot work Rewrite one recursive solution using a stack you control Phase 8: Harder practice — linked lists, stacks, and queues Insert and delete nodes in a singly linked list Reverse a singly linked list Find the middle of a linked list with a slow pointer and a fast pointer Find a loop in a linked list and the node where the loop starts Merge two sorted linked lists Check that brackets open and close in the right order Find the next bigger number to the right of each item Build a stack that can also tell you the smallest value quickly Implement a queue using two stacks Build a queue that wraps around when it reaches the end Phase 9: Harder practice — trees Print a binary tree in this order: left, node, right Print a binary tree in this order: node, left, right Print a binary tree in this order: left, right, node Print a binary tree one row at a time Find how many levels a binary tree has Check that the left and right sides of a tree are about the same height Find the closest shared parent of two nodes Add a number into a binary search tree Search for a number in a binary search tree Delete a number from a binary search tree Check that a tree follows the binary search tree rule Phase 10: Harder practice — heaps, word trees, and groups Add a number to a min-heap and take out the smallest Find the kth largest number using a small heap Merge several sorted lists using a heap Save words in a letter tree (trie) and search for a whole word Search for the start of a word in a letter tree (trie) Join two groups and check if two items are in the same group Count separate groups of connected items (union-find) Phase 11: Harder practice — graphs (points and connections) Store a graph as a list of neighbors for each point Walk a graph level by level (BFS) and record the distance from the start Walk a graph by going deep first (DFS), then turning back Find a loop in a graph whose links have no direction Find a loop in a graph whose links have a direction Order tasks so each one comes after the tasks it depends on Count islands in a grid Find the shortest path from one start point to the others (Dijkstra) Connect every point with the lowest total cost (Kruskal) Phase 12: Harder practice — greedy choices and dynamic programming Pick as many time ranges as you can without overlaps See if you can reach the end of a list by jumping Compute Fibonacci and remember answers you already found Compute Fibonacci by filling a table from the small numbers up Pick the best sum from a row of houses when you cannot pick neighbors Find the fewest coins that add up to an amount Pick items with the best total value without going over a weight limit Find the longest shared sequence of letters that stays in order Find the longest run of numbers that keep getting bigger Count ways to walk through a grid by reusing smaller answers Before a hard DP problem, write what each step remembers and how it changes Phase 13: Interview basics — core computer science in plain words Write a class and a child class that replaces one method Explain two methods with the same name: extra versions, versus a child class replacement Explain a process versus a thread, and one way two tasks can wait forever Explain how memory is split into pages, and what it means to switch tasks Mark the main key, the link to another table, and the unique column Write a SQL JOIN and a GROUP BY without looking them up Explain how an index can make a database search faster Describe what happens from the address bar until the first reply arrives Explain TCP versus UDP in a few simple sentences Explain safe database rules (ACID) using a money transfer Phase 14: Get ready — practice tests, interviews, and applications Finish 40 DSA Sheet problems and write the pattern name on each one Finish one medium problem in 45 minutes without looking at a solution Take four 90-minute practice tests with autocomplete turned off Solve again 10 problems you needed a solution to finish the first time Explain five solutions out loud, each in under 15 minutes Write one resume line with your language, how many problems you solved, and one project Complete one aptitude set in each week of placement season Do one mock interview and write down every question you missed Apply with this GitHub profile linked on the resume An easy path to a frontend job. Start with the browser, then HTML, CSS, and JavaScript. React and Next.js come after those basics.
Phase 1: Easy start — your laptop and the browser Install VS Code, Node.js, and Git Create a folder, initialize Git, and push it to GitHub Explain what happens when you type a URL and press Enter Tell HTTP from HTTPS, and a found page (200) from a missing page (404) Open DevTools and inspect an element on a real site Open one network request and point at the status code and the data that came back Phase 2: Easy practice — HTML that says what things are Build a page with header, main, nav, and footer Build a form where each label is tied to its box Use buttons for actions and links for navigation Add text that says what an image is for, for people who cannot see it Structure a list and a simple data table correctly Check the page outline in the accessibility panel in DevTools Phase 3: Next step — CSS layout Set text, color, and spacing with a few reusable values Lay out a row of cards with Flexbox Lay out a page with CSS Grid Make the same page usable on a phone and on a laptop Show a clear outline when someone moves around with the keyboard Build one component without a framework: a navbar or a card Fix a layout bug by looking at padding, border, and width in DevTools Phase 4: Next step — JavaScript in the browser Use const and let, and say when you would use each one Write conditionals, loops, and a function with a return value Change a list with map, keep some items with filter, and combine them with reduce Select one part of the page and change it from code Handle a click and an input event Load JSON data from a public API and wait for it with async/await Show a loading state and an error state for that fetch Explain where a variable lives, a function that remembers it, and the event loop Debug a broken script from the console instead of guessing Phase 5: Build on that — TypeScript, Git, and your tools Turn a JavaScript file into TypeScript and fix the type errors Type a function argument, a return value, and an object shape Describe the screen as one clear state, not a pile of maybe-flags Commit with a message that says what changed and why Open a branch, push it, and merge it with a pull request Create a Vite or Next.js app and run the dev server Install a package with npm and explain what package.json remembers Phase 6: Build on that — React Show a React piece that receives data from its parent Store changing data with useState and update it when the user acts Load data in useEffect and ignore a reply that arrives too late Move shared data up so two parts of the page stay in sync Share data with context only when passing it through many layers is painful Add routes and a not-found state Extract a reusable form field component Remember a slow calculation only after you have measured that it is slow Read a React warning and fix the cause, not the symptom Phase 7: Build on that — Next.js and page styling Create a Next.js App Router page and a shared layout Build a client component and a server component, and know which is which Fetch data on the server and pass it into the page Add a small server route that returns JSON data Style the page with small Tailwind classes Build the page from a few small pieces, not one giant file Set a title and description that match the page content Phase 8: Harder practice — access for everyone, speed, and tests Tab through your page and complete the main task with the keyboard Fix one contrast or name issue found by an accessibility checker Run Lighthouse and write down how fast the page loads, responds, and stays still Load a heavy piece later if the page does not need it at first Write a small test for a function that does not touch the page Write one browser test that clicks through a real user task Use an AI assistant to draft a component, then review and fix it yourself Phase 9: Get ready — a portfolio and interviews Publish one live page: a dashboard, a placement tracker, or a portfolio Write a README with setup steps, a screenshot, and what you would improve Add one resume line that names your tools and one thing a user can do Explain what happens from a click until the screen updates Answer how you would debug a slow page, using a metric Do one frontend mock and note the questions you could not answer Apply to internships with the live URL on your resume An easy path from a first web page to a full app. Start with HTML and JavaScript, then React, a database, login, and a public link.
Phase 1: Easy start — web basics you can finish Install VS Code, Node.js, and Git, and push a repository Build a page with clear HTML tags and a working form Lay the page out in a row or column and make it usable on a phone Update the page from JavaScript after a click Load JSON data and show an error if it fails Explain a request, a response, and a status code Open your page in DevTools and look at the elements and the network list Phase 2: Next step — one screen, then TypeScript Show a React piece using data passed in from outside Store input in state and submit it Style the screen with Tailwind Type a function and an object in TypeScript Load remote data and show loading, empty, and error states Add a second route Commit on a branch and open a pull request Phase 3: Build on that — Next.js as the app shell Create a Next.js app with one layout shared by the pages Add a page built on the server, and a piece that needs state in the browser Add a small server route that returns JSON data Read a value from the page URL and use it to filter a list Set the page title and a short description for the browser tab Show a clear not-found page when a record is missing Phase 4: Build on that — from a click to a saved row Create a database table with a main key and a link to another table Write a select, an insert, and a join yourself Connect the app to the database with Prisma and apply the table change Show database rows on the page from a server query Save a new row from a form and show it without refreshing by hand Let a signed-in user update and delete only their own row Show the list one page at a time Show an error next to the box that failed the check Phase 5: Harder practice — login and one full feature Add sign-up and sign-in with a scrambled password, or a login service Keep the user logged in after they refresh the page Hide private pages from people who are not logged in Build one full feature, such as saving applications on a placement tracker Reject bad input on the form and again on the server Write one browser test for the main success path of that feature Phase 6: Get ready — put the app on the internet Move passwords and keys into environment settings and keep them out of Git Deploy the app to a public URL Point the app at a database that is hosted online Apply the table changes to that online database Add a GitHub check that runs the test before you merge Write a README with a screenshot, setup steps, and one known limit Ask one classmate to use it and fix the bug they find Phase 7: Get ready — interviews and applications Draw the path from the button click to the database query Explain one choice in your tables, such as which column you indexed Solve 25 coding problems so online tests are not a surprise Write two resume lines: what the user can do, and which tools you used Prepare a five-minute walkthrough you can give on a call Do one mock and write down the questions you missed Apply to internships with the live link An easy path to a phone app. Learn JavaScript first, then build one screen, add more screens, connect data, and make a build you can install.
Phase 1: Easy start — JavaScript and TypeScript before the phone Install Node.js, VS Code, Git, and a phone simulator or Expo Go Write functions, arrays, and objects in JavaScript Type those values in TypeScript Fetch JSON and handle a failed request Push a repository to GitHub with a README Phase 2: Next step — one React Native screen Create an Expo app with TypeScript and run it on a device or simulator Lay out a screen with View, Text, and Pressable Build a list that stays smooth when it is long Store what the user types and show a message when it is not valid Style a screen that is usable on a small phone Add an image and a loading indicator Let the phone's back gesture work, and do not trap the user Phase 3: Build on that — moving between screens Add a screen stack so the user can open a second screen and go back Pass an id to the next screen and load the matching record Add a tab bar for the main sections of the app Show an empty state when a list has no rows Show an error state with a retry action Extract one reusable component, such as a list row Phase 4: Build on that — data, accounts, and the phone Call your own or a public API from the app Store the login token in secure storage, not in a loose global variable Sign in and sign out, and keep the user signed in after reload Save the last good reply so a bad network is obvious Save a small piece of local data and read it on next launch Ask for one permission, such as notifications, and handle it if the user says no Open a secure link from the app on the right screen Phase 5: Harder practice — fix bugs and make a build you can install Fix a layout bug on a narrow screen and on a tall screen Write one test for a function that formats or validates data Remove a console error you can reproduce Create a preview build you can install, using EAS or a similar tool Install that build on a real phone and complete the main task Record a 30-second screen capture of the main flow Phase 6: Get ready — portfolio, app store basics, and interviews Write a store-style description: who it is for and what it does Prepare screenshots at the sizes a listing asks for Read the Play console or App Store checklist before you pay any fee If a job post asks for Kotlin, build one simple Android screen and stop there Solve 20 coding problems. Mobile interviews still start with a coding test Write one resume line with the app, the tools, and the screen recording Do one practice interview about a screen, an API call, and what happens offline Apply with the repo, the capture, and the preview link An easy path toward product roles. Start with the job, then a real problem, one number to improve, a short plan, and interview practice.
Phase 1: Easy start — the job, in plain words Write what a product manager decides, and what an engineer still decides Follow one feature you use, from a complaint you had to the screen you see today Read one public product breakdown and rewrite it in your own words Watch a college fest, club app, or campus tool and list the people who run it Phase 2: Next step — find a problem worth writing down Pick a group of users you can actually talk to this month Talk to five of them about a recent real attempt, not a made-up one Write the problem as the situation, the pain, and how often it happens Estimate the group: who on campus, and how often Look at two other options they already use Drop the idea if you cannot find the pain in other people Write the problem in one sentence that does not name a feature Phase 3: Build on that — one number that matters, and a simple query Pick the one number that should improve if the pain gets better Write the top and bottom of that number, so you know how it is counted Separate a number that only looks good from the number that matters Sketch three steps from start to the result you care about Write a SQL query, or a sheet, that counts one of those steps Explain retention as people coming back, and pick the time window Name one number you refuse to make worse while you improve the main one Phase 4: Build on that — choose one small piece and write it down List five possible ideas and score them on how many people, how much it helps, how sure you are, and how hard it is Cut the list to one small piece a team could finish in two weeks Write a short product plan: problem, users, story, what you will not build, and the number to watch Write checks a tester could use to say the work is done Draw the flow, even if a designer will redraw it Write the assumption that would make you stop Phase 5: Harder practice — work with design and engineering Explain a client, a server, and a database in words an engineer will not correct Ask an engineer what is hard before you promise a date Turn feedback into a change in the plan, not a new slogan Order the work so the important number can move before the polish Write a release note a user can understand Write down one decision and the option you rejected Phase 6: Harder practice — launching, including AI features Write what a failed launch looks like before you launch Read the number after a real or practice launch Write what you would change in week two For an AI idea, name the input, how it can fail, and the human check Drop a chatbot that is not better than what people already do Tell the story in six slides: problem, evidence, the idea, the number, the risk, and what you need Phase 7: Get ready — product interviews and applications Practice a product case out loud: clarify, user, pain, solution, risks Practice a size estimate with clear steps, not a magic number Prepare one technical story from a project you actually built or planned Prepare a story where you changed your mind because of evidence Write a resume that shows decisions, not a list of tools Apply to junior product roles with the six-slide story attached An easy path into testing jobs. Start with what a test is for, then write clear cases, check an API, and automate one user flow.
Phase 1: Easy start — what testing is for Explain a requirement as something a user can see happen Name a small code test, an API test, and a full user-flow test, and who usually writes each Explain a quick 'does it start' check versus a bigger set of tests that old bugs stay fixed Explain how bad a bug is versus how soon the team should fix it Read a short user story and list what 'done' must include Set up a free task board and move a ticket across columns Phase 2: Easy practice — test cases and bug reports people can read Write a test with steps, sample data, and the result you expect Write a test for a bad input on the same feature Write a test for an edge, such as empty input or the longest allowed text File a bug with where you saw it, the steps, what happened, what should happen, and proof Test a fixed bug again and say whether the fix still works Match three tests to the requirement they cover Remove a test that cannot fail in a way a user would notice Phase 3: Next step — the browser, HTTP, and SQL Use DevTools to watch a click become a network call Read the method, the status code, and the JSON data Explain these status codes in your own words: 200, 201, 400, 401, 403, 404, and 500 Find one part of the page and say how you would find it again in a test Write a SQL query that checks a row your test just created Reset test data so the next run does not depend on the last one Phase 4: Build on that — API tests Send a GET request and check the status and one field Send a POST with good data, then with data the API must reject Call a protected route without a login token and expect a refusal Make two calls in a row: create an item, then fetch it Save the requests so someone else can run them Run those saved requests from the terminal Phase 5: Build on that — TypeScript for test code Write variables, conditions, loops, and functions in TypeScript Describe the shape of the reply your test checks Throw a clear error when a field you expect is missing Put shared setup in one helper so tests do not copy it Run the test file from the terminal Read a failure and point at the check that failed, not the whole log Phase 6: Harder practice — Playwright on one real user flow Install Playwright and open a page Find a button or link by its role and its name Finish one user task: sign in, create an item, or submit a form Check what the user should see, not only that a click happened Wait for the page to be ready instead of pausing for a fixed number of seconds Run the same test twice, on your computer or in the automatic check Save a trace or a screenshot when the test fails Recognize an older Selenium test, and use Playwright for new tests Phase 7: Get ready — automated checks, a portfolio, and interviews Run the browser test automatically on GitHub Make the build fail when the test fails Add one access check, such as a button with a name, to the same flow Write a short test plan for a feature you did not build Prepare three stories: a bug you filed, a flaky test you fixed, and a case you chose not to automate Solve 15 coding problems if you want a job that mixes testing and code Apply with the repo, the green check, and one sample bug report An easy path into design. Start by noticing a screen, then talk to people, sketch the flow, build it in Figma, and test it.
Phase 1: Easy start — looking at a screen Create a free Figma account and open a blank file Pick two text sizes and use only those on one screen Pick a text color that is easy to read on its background Space a screen with one spacing size, not many random gaps Decide what the user should notice first, and make the screen match that Group related items so the screen reads in chunks Redraw a crowded college page section with half the items Phase 2: Next step — research with real people Write a problem you have seen, not a feature you already want to draw Talk to five people about the last time they hit that problem Take notes in their words, separate from your own ideas Group the notes into themes Write one example user only if the interviews support it Map the steps they take today, including the workaround Look at two other products and note one behavior, not one color Phase 3: Build on that — structure the flow List the tasks the product must support Draw the steps for the main task, including a dead end Sketch the screens that flow needs Remove a screen that does not help the task Write the button labels in words the user would use Check the flow against one thing a person actually said Phase 4: Build on that — Figma, one skill at a time Build one phone-sized frame and one laptop-sized frame Use auto layout so a text change does not break the row Create one color style and one text style, and use only those Build a button with a normal state and a disabled state Build a text box with an error state Build one screen from those pieces Make the phone frame reflow without designing a second unrelated screen Name every layer so a developer can find it Phase 5: Harder practice — a clickable prototype and a test Link the main task into a clickable prototype Write a test of tasks, not a tour of your favorite screens Watch five people use it, and do not explain while they struggle Write each failure as what they said, plus the screen Change one flow because of what you saw Use an AI layout tool only as a draft, then fix it from the test notes Phase 6: Harder practice — handoff and access for everyone Mark heading order, labels, and keyboard focus for the main task Show what empty, loading, and error look like Write notes for spacing that auto layout does not already show Sit with someone who codes and watch them build one screen Fix the spec anywhere they had to guess Check that text is readable and buttons are big enough on the phone frame Phase 7: Get ready — a case study and the interview Write the case as the problem, the research, the decision, the test, and the result Show the early rough sketch next to the final screen Publish it on a simple site, not only as an image post Prepare a 15-minute presentation Explain one thing you removed and why If you code, build the same flow on the frontend roadmap so the case has a real page Apply to design internships with the case link and a PDF backup Related tools Roadmap FAQs What are Underrated Coder roadmaps? Roadmaps are step-by-step learning paths for students. They start with easy topics and get harder only after the basics. Paths include DSA, Full Stack, Frontend, Backend, AI, Cloud, and more. Each checkbox is one small step. Signing in saves those ticks to your account. Each path also has Coder AI help and a Projects tab with guides you can build.
Are roadmaps free? Yes. Browsing roadmaps, ticking milestones, and opening project build guides is free. Signing in saves roadmap progress to your account. Pro and Pro Max add live classes, full DSA Sheet depth, aptitude modules, interview banks, and Coder AI credits — see Pricing for the exact list on each plan.
Do I need Pro to use roadmap project guides? No. Project guides (recommended stack, phased checklists, mentor tips, resume lines) are open on the platform. Pro helps you go deeper with live teaching, mentorship-style batches, and premium practice tools alongside the same roadmaps.
How do I save my roadmap progress? Sign in with Google. Your checked milestones sync to your account. Project task checkboxes on build-guide pages save in your browser for now; roadmap milestone sync is separate in the track view.
What is the Projects tab on each roadmap? It lists three level-based project ideas (beginner → advanced) updated for 2026 hiring — for example placement tracker SaaS, mini online judge, or Next.js portfolio hub. Each opens a full guide with small steps written for beginners, not just high-level bullet points.
Which roadmap should I pick for campus placements? Pick one main path and also do DSA if you are preparing for placements. Full Stack or Backend fits web jobs. AI fits data and machine learning jobs. Read the short line under each path, then stay with one path for 8–12 weeks before you switch.
How much time should I spend on roadmap milestones per week? Plan 5–8 hours per week alongside college: 2–3 hours theory milestones, 3–5 hours practice (DSA Sheet, compiler, or project steps). Consistency beats cramming before placement season.
Can roadmaps replace my college syllabus? No — they complement it. Use roadmaps for interview skills and projects; use college courses for grades and fundamentals. Align elective projects with roadmap Projects when your professor allows choice.
How do roadmaps connect to Pro and Pro Max live classes? Pro includes one coding live batch (Java + DSA or Full Stack — you choose at checkout). Pro Max includes every subscription-eligible coding live batch for your term. After payment, open My Live Classes for join links, recordings, and assignments. Roadmaps show what to self-study between sessions.
Where do I see my batch and subscription status? My Live Classes in the sidebar for batches and recordings. Account → Plan Details for Pro/Pro Max tier and validity. Pricing page lists which premium passes (DSA Sheet, aptitude, Coder AI, compiler) your plan unlocks.
Is Coder AI on the roadmap the same as Coder AI elsewhere? Yes — the roadmap AI tutor tab uses your plan’s Coder AI credits. Free users get limited usage; Pro and Pro Max include higher monthly allocations for hints, explanations, and study help on milestone topics.
What is the best order: roadmap, notes, DSA Sheet, or quiz? Typical flow: read Coding Notes for syntax → follow roadmap milestones → practice on DSA Sheet → test concepts with Coding Quiz → build one Projects tab guide per semester. Adjust if your placement drive is in the next 60 days — prioritize DSA Sheet + mock quizzes.
What are roadmap rankings? Rankings gamify consistent learning across the community. They are optional motivation — your placement outcome still depends on problem-solving depth, projects, and interview practice, not rank alone.
I feel overwhelmed by a long roadmap. Where do I start? Open only the first milestone section. Tick one item per day. Use Projects only after ~30–40% of milestones — early wins matter more than reading the entire path on day one.
How often are roadmaps updated? Tracks and project guides are refreshed for current stacks (for example Next.js App Router, modern auth, 2026 project ideas) and hiring patterns. Milestone lists evolve as we add community feedback and industry input.