

 Personal Recommendation / Opinion Find the detailed version of this roadmap


 Alternative Option - Pick this or purple along with resources and other roadmaps


 Order in roadmap not strict (Learn anytime)
https : // roadmap.sh
 I wouldn't recommend
Backend




 How does the internet work? DNS and how it works?

What is Domain Name




 What is HTTP? Internet




 Browsers and how they work? What is hosting?


 Rust Go 
 Git 
 

GitHub

Learn a Language Version Control Systems



GitLab

Repo hosting services



Bitbucket

 Java JavaScript 


 C# Python 

Terminal Usage 


 PHP Ruby 

POSIX Basics
stdin, stdout, stderr, pipes




 PostgreSQL


 MySQL OS and General Knowledge
Relational Databases

 MariaDB
Basic Terminal Commands

 MS SQL grep, awk, sed, lsof, curl, wget


tail, head, less, find, ssh, kill, dig



 Oracle


  

How OSs work in General
NoSQL Databases 


 MongoDB InfluxDB 

Memory Management

 CouchDB TimeScale 


 ORMs Interprocess Communication
Document DBs Time Series 


 ACID
I/O Management


 Firebase Cassandra 
 
 Transactions
Basic Networking Concepts

 RethinkDB HBase 
 
 N+1 Problem
Threads and Concurrency

 Realtime Column DBs 
 
 Normalization
Process Management


 
 Failure Modes
Redis 
 Neo4j
Operating Systems Knowledge
Graph DBs 
 Profiling Perfor.

 DynamoDB

Key-Value Database Indexes 



  More about Databases
Data Replication 

Sharding Strategies 


 HATEOAS Learn about APIs Scaling Databases
CAP Theorem 


 Open API Specs


 Authentication REST 

JSON APIs 
 Client Side 


 Cookie Based Redis 

SOAP 
 Caching Server Side

 OAuth
Memcached 


 Basic Auth
gRPC 
 CDN 


 Token Auth GraphQL 




 JWT Web Security Knowledge
MD5 and why not to use it

 OpenID
SHA Family

 SAML 
 Integration Testing

scrypt bcrypt

 Unit Testing
Testing Hashing Algorithms

 Functional Testing

HTTPS OWASP Risks

Software Design & Architecture CI / CD 

CORS SSL/TLS

Content Security Policy

Design and Development Principles




 GOF Design Patterns
Architectural Patterns Monolithic Apps 


 Domain Driven Design
Microservices 


 Test Driven Development
SOA 


 CQRS 
 Elasticsearch
Serverless 


 Event Sourcing

 Solr
Service Mesh 

Search Engines
Twelve Factor Apps 


 RabbitMQ


 Kafka

 Kubernetes
Docker 

Message Brokers
Containerization vs Virtualization LXC 



 Server Sent Events 
 WebSockets GraphQL Apollo 


 Nginx
Relay Modern 


 Apache




 Caddy
Graceful Degradation
Web Servers

 MS IIS
Throttling

Backpressure


Loadshifting
Instrumentation
Building for Scale
Circuit Breaker
Monitoring
Mitigation Strategies
Telemetry

Di!erence between these

Migration Strategies 

Types of Scaling 



Observability
Metrics logging and other
Have a look at the DevOps Roadmap observable items that can help
in debugging and solving
DevOps Roadmap
Issues when things go wrong.
 Find the detailed version of this roadmap
References / Other Resources along with resources and other roadmaps


 Coding Interview University
https : // roadmap.sh

 OpenSource Society University - CS

 Teach Yourself Computer Science
Computer Science Important Note / Click here



C++ Python

C Pick a Language Go

Java C#

Rust

Linked List Array

Stack Big O Notation

Queue Data Structures Asymptotic Notation Big-θ Notation

Hash Table Big-Ω Notation

Graph Heap
Tree
Common Runtimes
Bubble Sort
Constant
Binary Tree Directed Graph Selection Sort
Logarithmic
Binary Search Tree Undirected Graph Insertion Sort
Linear
Full Binary Tree Spanning Tree Heap Sort
Polynomial
Complete Binary Tree Representation Quick Sort
Exponential
Adjacency Matrix
Balanced Tree Merge Sort
Factorial
Adjacency List Sorting
Unbalanced Tree

Recursion
Graph Tree Common Algorithms
Tail Recursion
Breadth First Search Pre-Order Traversal
Non-Tail Recursion
Depth First Search In-Order Traversal
Search Pattern in Text
Bellman Ford's Algorithm Post Order Traversal Searching
Su#x Arrays
Dijkstra's Algorithm Breadth First Search Binary Search

A* Algorithm Depth First Search Linear Search

String Search & Manipulations

Caches
Greedy Algorithms Back Tracking Substring Search
LRU Cache
Dijkstra's Algorithm Finding Hamiltonian Paths Brute Force Search
LFU Cache
Hu"man Coding Solving N Queen Problem Knuth-Morris Pratt
MFU Cache
Kruskal's Algorithm Maze Solving Problem Boyer-Moore

Ford-Fulkerson Algorithm The Knight's Tour Problem Rabin-Karp

Bitwise Operators
Prim's Algorithm
Rabin-Karp Algorithm
Big Endian Floating Point Numbers

GoF Design Patterns Little Endian Endianess

Architectural Patterns
Unicode ASCII
Dependency Injection

Null Object Pattern Class Diagrams

Character Encodings
Type Object Pattern Activity Diagrams

Usecase Diagrams

Design Patterns Common UML Diagrams

Activity Diagram

Statemachine Diagram
Basic Math Skills Complexity Classes
Sequence Diagrams

Probability Combinatorics
P NP Co-NP NP Hard

NP Complete P = NP Tries

SQL vs NoSQL Databases

Travelling Salesman Problem
AVL Trees
Normalization / Denormalization
Knapsack Problem
Red / Black Trees
Entity-Relationship Model
Longest Path Problem 2-3 Search Trees
DDL DML DQL DCL

Locking Transactions Balanced Search Trees

Horizontal vs Vertical Scaling
ACID Model BASE Model

Load Balancing 2-3-4 Trees

CAP Theorem PACELC
K-ary / M-ary Tree
Indexes Views System Design
B-Tree
Transactions
Clustering Caching
Stored Procedures
CDN Proxy
Database Federation
CAP Theorem Queues
Replication Sharding
Architectural Styles
Process Forking
Databases REST GrqphQL gRPC
Memory Management
Cloud Design Patterns
Lock / Mutex / Semaphore
OSI Model Long Polling Short Polling
Concurrency in Multiple cores
TCP / IP Model Web Sockets SSE
Scheduling Algorithms
DNS HTTP
How CPU executes programs? CPU Interrupts
TLS & HTTPS
How computers calculate? Processes vs Threads
Networking
Sockets

Security How Computers Work Processes and Threads

Public Key Cryptography Registers and RAM

Hashing / Encryption / Encoding Instructions and Programs

Hashing Algorithms CPU Cache

OWASP Top 10

Skip Lists K-D Trees

Have a look at the following Web Development related Roadmaps

Frontend Roadmap Backend Roadmap

 
 Beginner Topics / Start with these


 Intermediate Topics / Pick them next
Find the detailed version of this roadmap

 Advanced Topics / Pick them in the end
along with resources and other roadmaps

 Optional / Learn if you want
https : // roadmap.sh
C++
References / Additional Resources


 Salmer’s C++ Roadmap

What is C++? 


 Installing C++ 
 Introduction to the Language Why use C++? 


 Code Editors / IDEs
C vs C++ 


 Running your First Program

 Arithmetic Operators


 Logical Operators 
 RTTI


 Setting up your Environment

 Loops: for/while 
 Operators


 Dynamic Typing

 Bitwise Operators 
 Lambda


 Static Typing


 weak_ptr

 Basic Operations 
 Functions Data Types 


 shared_ptr


 unique_ptr

 References

Smart Pointers

Pointers and References 


Raw Pointers
Code Splitting: Headers / CPP Files 
 Forward Declaration 


 New/delete Operators 
 Memory Model

Scope 
 Namespaces 


 Memory Leakage

 Lifetime of Objects
Structuring Codebase 



 Overloading of Functions
Rule of Zero, Five, Three 


Static Polymorphism


Object Oriented Programming 
 
 Structures and Classes
Dynamic Polymorphism 


 Virtual Methods Virtual Tables 
 Multiple Inheritance 


Access Violations 

Diamond Inheritance 


 static_cast
auto (Automatic Type Deduction) 
 Exceptions 


 const_cast
Type Casting 
 Exit Codes 
 Exception Handling 


 dynamic_cast
Undefined Behavior (UB) 

 reinterpret_cast

Argument Dependent Lookup (ADL) 




 Name Mangling Macros 
 Language Concepts


 Iterators 
 iostream


 Full Template Specialization 
 Variadic Templates 
 Algorithms 
 Date / Time Standard Library + STL 



 Partial Template Specialization  Template Specialization
 
 Multithreading 
 Containers


 Type Traits


 SFINAE Templates 

 RAII
 
 Pimpl 
 CRTP

 Non-Copyable/Non-Moveable
 C++11/14 




 Erase-Remove Idioms C++17 



 Copy and Swap C++20 



 Copy on Write Newest 



 Standards C++0x 



 Understand Compiler Stages Language Tools


 


 Compilers Debuggers Understanding Debugger Messages

Debugging Symbols



 Di!erent Compilers and their Features

Clang++/LLVM

 WinDBg GDB 

Intel C++
CMAKE 

MSVS C++
Makefile 
 
 vcpkg Spack 

GCC
MinGW Ninja 
 
 Conan NuGet 


Build Systems 
 Package Managers 



 

Frameworks Libraries


 gtest/gmock 
 Boost OpenCV 
 Working with Libraries 



 Qt 
 POCO protobuf 

Library Inclusion 


 Catch2  gRPC
 tensorflow 

Licensing 


 Orbit Profiler 
 pybind11 spdlog 



 PyTorch C++ 
 opencl fmt 



 ranges_v3

Continue Learning with following relevant tracks

Backend Roadmap
 CTFs (Capture the Flag) Find the detailed version of this roadmap
along with resources and other roadmaps
HackTheBox

Cyber Security https://roadmap.sh

TryHackMe

VulnHub

picoCTF
Fundamental IT Skills

SANS Holiday Hack Challenge

Computer Hardware Components

Connection Types and their function NFC WiFi Bluetooth Infrared

Certifications

Beginner Certifications OS-Independent Troubleshooting

CompTIA A+ CompTIA Linux+ Understand Basics of Popular Suites iCloud Google Suite Microsoft O!ce Suite

CompTIA Network+ CCNA Basics of Computer Networking

CompTIA Security+ Windows Linux MacOS

Advanced Certifications
Operating Systems
CISSP CISA CISM Basics of Subnetting

GSEC GPEN GWAPT Public vs Private IP Addresses Learn following for Each

GIAC OSCP CREST IP Terminology Installation and Configuration

CEH localhost loopback CIDR

Di"erent Versions and Di"erences

subnet mask default gateway

Navigating using GUI and CLI

Understand the Terminology Understand Permissions

VMWare VirtualBox esxi proxmox VLAN DMZ ARP VM Installing Software and Applications

Common Virtualization Technologies NAT IP DNS DHCP Performing CRUD on Files

Hypervisor VM GuestOS HostOS Router Switch VPN Troubleshooting

Understand basics of Virtualization Common Commands

MAN LAN WAN WLAN

Troubleshooting Tools
Understand these

nslookup iptables Packet Sni"ers

DHCP DNS NTP IPAM
Understand the OSI model
ipconfig netstat Port Scanners
Function of Each

ping dig arp Protocol Analyzers

Network Topologies Networking Knowledge

nmap route tcpdump tracert

Star Ring Mesh Bus
Common Protocols and their Uses
Authentication Methodologies Understand Common Protocols
Common Ports and their Uses
Kerberos LDAP SSO SSH RDP FTP SFTP
SSL and TLS Basics
Certificates Local Auth RADIUS HTTP / HTTPS SSL / TLS
Basics of NAS and SAN

Understand Common Hacking Tools

Core Concepts of Zero Trust

Understand Common Exploit Frameworks
Blue Team vs Red Team vs Purple Team
Roles of Compliance and Auditors
Understand Concept of Defense in Depth
False Negative / False Positive
Understand the Definition of Risk True Negative / True Positive
Understand Concept of Runbooks

Understand Backups and Resiliency Basics of Threat Intel, OSINT

Understand Basics of Forensics

Basics and Concepts of Threat Hunting Cyber Kill Chain MFA and 2FA Understand Handshakes

Basics of Vulnerability Management Operating System Hardening Understand CIA Triad

Basics of Reverse Engineering Understand the Concept of Isolation Privilege escalation / User based Attacks

Penetration Testing Rules of Engagement Basics of IDS and IPS Honeypots Web Based Attacks and OWASP 10

Perimiter vs DMZ vs Segmentation Authentication vs Authorization Learn how Malware Operates and Types

Security Skills and Knowledge

Tools for Incident Response and Discovery Basics of Cryptography Attack Types and Di"erences

nmap tracert nslookup dig curl Salting Hashing Key Exchange

Phishing vs Vishing vs Whaling vs Smishing

ipconfig hping ping arp cat dd PKI Pvt Key vs Pub Key Obfuscation Spam vs Spim Shoulder Surfing

head tail grep wireshark winhex Dumpster Diving Tailgating Zero Day
Understand Secure vs Unsecure Protocols

memdump FTK Imager autopsy Social Engineering Reconnaissance

FTP vs SFTP SSL vs TLS IPSEC

Understand Frameworks DNSSEC LDAPS SRTP S/MIME Impersonation Watering Hole Attack

ATT&CK Kill chain Diamond Model Drive by Attack Typo Squatting

Understand the following Terms

Brute Force vs Password Spray

Understand Common Standards Antivirus Antimalware EDR DLP

ISO NIST RMF CIS CSF Firewall and Nextgen Firewall HIPS Common Network Based Attacks

Understand Common Distros for Hacking NIDS NIPS Host Based Firewall DoS vs DDoS MITM ARP Poisoning

SIEM SOAR ParrotOS Kali Linux Sandboxing ACL EAP vs PEAP Evil Twin DNS Poisoning Spoofing

WPA vs WPA2 vs WPA3 vs WEP WPS Deauth Attack VLAN Hopping

Using tools for unintended purposes

LOLBAS Rogue Access Point War-driving/dialing

Understand the Incident Response Process

Preparation Identification
Learn how to find and use these logs Bu"er Overflow Memory Leak XSS

Event Logs syslogs netflow Containment Eradication

SQL Injection CSRF Replay Attack

Packet Captures Firewall Logs Recovery Lessons Learned

Pass the Hash Directory Traversal

Understand Hardening Concepts Understand Threat Classification Understand Audience

MAC-based NAC-based Port Blocking Zero Day Known vs Unknown APT Stakeholders HR Legal Compliance

Group Policy ACLs Sinkholes Patching Management

Understand Common Tools

Jump Server Endpoint Security

VirusTotal Joe Sandbox any.run urlvoid urlscan WHOIS

Cloud skills and Knowledge

Understand concepts of security in the cloud Understand Cloud Services Common Cloud Environments

SaaS PaaS IaaS AWS GCP Azure

Understand the basics and general flow of deploying in the cloud

Understand the di"erences between cloud and on-premises

Cloud Models Common Cloud Storage
Understand the concept of infrastructure as code
Private Public Hybrid S3 Dropbox Box

Understand the concept of Serverless

OneDrive Google Drive

Understand the concept of CDN

iCloud

Programming Skills and Knowledge (Optional But Recommended) Python

Go

JavaScript

C++

Keep Learning Bash

Power Shell
 Find the detailed version of this roadmap

 Personal Recommendation / Opinion along with resources and other roadmaps

 Alternative Option - Pick this or purple
https : // roadmap.sh

 Order in roadmap not strict (Learn anytime)

DevOps
Featured DevOps Resources


 DevOps Bootcamp by Nana Paid

 Python Ruby 


 KodeCloud DevOps Courses Paid
Learn a Programming Language 
 Go Rust 

These are a"liate links. Revenue generated
from these help o!set roadmap.sh running costs.
JavaScript / Node.js 


If you are just getting started, visit the simplified

Operating Systems
version listing learning tips and ideas.

Visit the Beginner Version

Linux Unix


 Windows 
 Ubuntu / Debian FreeBSD 


 SUSE Linux OpenBSD 

Nginx 
 
 RHEL / Derivatives NetBSD 

Tomcat 

Editors Scripting Learn to live in Terminal
Apache 


 Vim/Nano/Emacs Bash Scripting 

IIS 
 Process Monitoring 

Power Shell 


 Reverse Proxy Web Servers 
 GitHub Performance Monitoring 



 Forward Proxy Caching Server 
 
 GitLab Networking Tools 



 Firewall Load Balancer 
 
 Bitbucket 
 Git Text Manipulation 


What is and how to setup a _____? VCS Hosting Version Control Systems


 FTP / SFTP DNS 

LXC 
 
 AWS Google Cloud 
 
 HTTP HTTPS 

Containers
Docker 
 
 Azure Digital Ocean 
 
 SSL / TLS SSH 


Cloud Providers Networking, Security and Protocols


 Alibaba Cloud Linode 
 
 OSI Model


 Heroku Vultr 
 
 Email

 AWS CDK

White/Grey Listing

 CloudFormation

 Cloudflare AWS Lambda 

SMTP DMARC

 Pulumi

 Azure Functions GCP Functions 

IMAPS SPF

 Terraform

 Vercel Netlify 

POP3S Domain Keys

Infrastructure Provisioning Serverless

Ansible 
 
 Gitlab CI Jenkins 
 Sealed Secrets 

Configuration Management Chef 
 
 GitHub Actions Travis CI 
 Cloud Specific Tools 

Puppet 
 
 Circle CI Drone 
 
 Vault SOPS 


Learn some CI/CD Tool Secret Management

TeamCity 


Azure DevOps Services 



 Jaeger New Relic 



 AppDynamics Datadog 
 
 Zabbix Prometheus 

Infrastructure Monitoring

 OpenTelemetry 
 Datadog Grafana 


Application Monitoring

GKE / EKS / AKS 

  Artifactory
 Nexus 



 Elastic Stack Loki 
 AWS ECS / Fargate 
 Cloud Smith 


Logs Management Container Orchestration Artifact Management


 Graylog Splunk 
 Docker Swarm 
 ArgoCD 



 Papertrail Kubernetes 
 FluxCD 


Cloud Design Patterns Service Mesh GitOps

Availability 
 Istio Consul 


Data Management 
 Linkerd Envoy 


Design and Implementation

Management and Monitoring

Keep Learning
Roadmap was made in partnership
Find the detailed version of this roadmap
with Sid Palas. Checkout his free
along with resources and other roadmaps
course covering this topic in depth.
Docker https://roadmap.sh

 Kubernetes Roadmap


 DevOps Roadmap


 Backend Roadmap
What are Containers?

Why do we need Containers?

Package Managers Introduction
Bare Metal vs VMs vs Containers
Users / Groups Permissions
Docker and OCI
Shell commands

Shell scripting

Underlying Technologies Namespaces cgroups

Linux Fundamentals

Union Filesystems
Programming Lanuage
Just get the basic idea of these.
Application Architecture

Web Development
Installation / Setup Docker Desktop ( Win / Mac / Linux)

Prerequisites
Docker Engine ( Linux )
Basics of Docker

Ephemeral container filesystem

Using 3rd Party Container Images Data Persistence
Volume Mounts Bind Mounts

Databases Image Tagging Best Practices

Interactive Test Environments Others (ghcr, ecr, gcr, act, etc)

Command Line Utilities Dockerhub Runtime Configuration Options

Building Container Images Container Registries docker compose

docker run
Dockerfiles

E!cient layer caching

Image size and security Runtime Security Running Containers

Image Security

Images Containers

Docker CLI Container Security

Volumes Networks

Developer Experience Deploying Containers

Hot Reloading PaaS Options

Debuggers Kubernetes

Tests Docker Swarm

Continuous Integration Nomad

Continue Learning with following relevant tracks

Backend Roadmap DevOps Roadmap

 Personal Recommendation / Opinion For resources and other roadmaps
Alternative Option - Pick this or purple https://roadmap.sh
Order in roadmap not strict (Learn anytime) Are you just getting started?
I wouldn't recommend
Front-end Visit the Beginner Version

Internet How does the internet work?

What is HTTP?

Learn the basics What is Domain Name?

Writing Semantic HTML

What is hosting?

HTML Forms and Validations

DNS and how it works?

Accessibility
Browsers and how they work?

SEO Basics

Git

CSS Learn the basics Learn the Basics

Version Control Systems

Making Layouts Learn DOM Manipulation

VCS Hosting

Responsive Design Fetch API / Ajax (XHR)

GitHub

JavaScript
GitLab

Bitbucket
We have trimmed down the CSS part for the sake of brevity.
However, I would recommend reading about CSS in JS,
React
CSS Modules, Styled Components, Vanilla Extract, Panda CSS npm
and look into di!erent frameworks with pre-built components Vue.js
pnpm
such as MUI, daisyUI, Chakra UI and Mantine.
Angular
yarn

CSS Architecture Writing CSS Pick a Framework Package Managers

BEM Tailwind Svelte

Vite
Parce

Radix UI Solid JS esbuild

Webpack

CSS Preprocessors Qwik Webpack

Webpack

Shadcn UI Rollup
Rollu

Sass Module Bundlers Parcel

Parce

PostCSS Task Runners npm scripts

Build Tools Linters and Formatters Prettier

ESLint

Authentication Strategies Testing your Apps Vitest

JWT, OAuth, SSO, Basic Auth, Session Auth etc
Jest

Playwright
Web Security Basics CORS HTTPS Learn the di!erence between Unit, Integration,
and Functional tests and learn how to write
Cypress
Content Security Policy them with the tools listed on the right.

OWASP Security Risks

Next.js

React Remix
HTML Templates
Angular Universal
Web Components Custom Elements
Vue.js Nuxt.js
Shadow DOM
Svelte Svelte Kit
Type Checkers TypeScript

Server Side Rendering (SSR)

Storage PRPL Pattern Apollo GraphQL

Web Sockets RAIL Model
Relay Modern
Server Sent Events Performance Metrics
Service Workers Using Lighthouse

Location Using DevTools

Progressive Web Apps Static Site Generators
Notifications Calculating, Measuring
Device Orientation and improving performance
Vuepress Astro
Payments
Performance Best Practices
Credentials Jekyll Eleventy

Learn di!erent Web Hugo Next.js

Electron
APIs used in PWAs
Nuxt.js Remix
Tauri

Flutter

Mobile Applications
Bonus Content Desktop Applications

React Native

Flutter

Ionic

NativeScript
Continue Learning with following relevant tracks

TypeScript Roadmap Node.js Roadmap

 Audience Note Find the detailed version of this checklist
With details on how to implement these
If you are already a full-stack developer
you should visit these roadmaps instead. https://roadmap.sh

Full Stack Frontend Backend DevOps

Target audience for this roadmap is Project Ideas Inside

absolute beginners wanting to get into Key topics to learn

full stack development. Change of Domain

HTML CSS JavaScript

Checkpoint — Static Webpages Checkpoint — Interactivity npm

Checkpoint — Collaborative Work Checkpoint — External Packages

React Tailwind GitHub Git

Feel free to skip and revisit

after learning some backend.

You can pick any backend programming language.

My recommendation is Node.js because you are
Checkpoint — Frontend Apps
already familiar with JavaScript and it’s easier to pick.

Start Backend Development Node.js

Checkpoint — CLI Apps

Backend Starts Here
Learn Frontend Frameworks
If you skipped earlier PostgreSQL

Checkpoint — Simple CRUD

Redis JWT Auth RESTful APIs

Use the checkpoints and do not forget

Checkpoint — Complete App
to practice what you learn. There are
project ideas at each checkpoint that
Route53 SES you can build to solidify your knowledge.

Get Some DevOps Knowledge EC2 VPC S3

Linux Basics Basic AWS Services

Checkpoint — Deployment

Monit

Checkpoint — Automation Checkpoint — CI / CD Checkpoint — Monitoring

Ansible GitHub Actions

Terraform

Checkpoint — Infrastructure

Continue Learning with following relevant tracks

Frontend Roadmap Backend Roadmap DevOps Roadmap

 Find the detailed version of this roadmap

Backend Roadmap till Language Selection along with resources and other roadmaps

roadmap.sh/backend
http : // roadmap.sh

Java
DataStructures
Basic Syntax

Learn the Fundamentals OOP, Interfaces, Classes

DataTypes, Variables

Packages
Conditionals
Loops
Functions Working with Files and APIs

Exception Handling
Generics
Memory Management How JVM works?

Collection Framework Getting Deeper Garbage Collection

Serialization Basics of Threads

Streams
Networking & Sockets
Spring

Gradle Build Tools Web Frameworks Spring Boot

Maven Play Framework

JPA Logback
Ant Spark

Log4j2
Spring Data JPA ORM

Hibernate Logging Frameworks TinyLog

EBean JDBC

Mocking > Mockito Behavior Testing

JDBI3
Cucumber-JVM
JDBC Template Testing your Apps
Cukes JBehave

Unit Testing Integration Testing

JUnit REST Assured

TestNG JMeter Backend Roadmap after Language Selection

roadmap.sh/backend
 Find the detailed version of this roadmap
!
" Beginner Topics / start with these
along with resources and other roadmaps
"
! Intermediate Topics / pick them after beginner topics

"
! Advanced Topics / pick these after intermediate topics http : // roadmap.sh

JavaScript

var let const

"
! What is JavaScript?

"
! History of JavaScript Introduction to JavaScript "
! Variable Declarations "
!
"
! JavaScript Versions
"
! All About Variables Hoisting "
!
"
! How to run JavaScript? Variable Naming Rules "
!

Variable Scopes "

!
"
! Prototypal Inheritance
! string
" undefined "
!
"
! Object Prototype Block Function Global
"
! number bigint "
! "
! "
! "
!

"
! boolean null "
! "
!
"
! Data Types Object Built-in Objects "
!
"
! Symbol
typeof operator "
!
Primitive Types
Explicit Type Casting "
!

"
! Type Conversion vs Coercion Type Casting "
! Implicit Type Casting "
!

"
! Map

Keyed Collections "

! Data Structures "
! Indexed Collections "
!
"
! Weak Map

"
! Set
! Typed Arrays
" Arrays "
!
"
! Structured Data

"
! Weak Set

"
! JSON
isLooselyEqual "
!
"
!
isStrictlyEqual "
!
== === Object.is
"
! Equality Comparisons Equality Algorithms "
!
Value Comparison Operators
SameValueZero "
!
SameValue "
!
"
! for statement for...in statement "
!

"
! do...while statement for...of statement "
!

"
! while statement "
! Loops and Iterations break / continue "
! Labeled Statements "
!

"
! Conditional Statements "
! Control Flow Exception Handling "
! throw statement "
!

try / catch / finally "

!
"
! If...else Switch "
!
Defining and Calling Functions "
! Utilizing Error Objects "
!

"
! Expressions and Operators Functions "
! Function Parameters "
! Default Params "
!
Arrow Functions "
! Rest Params "
!
"
! Assignment Operators
IIFEs "
!
"
! Comparison Operators
arguments object "
! Recursion "
!
"
! Arithmetic Operators
Scope & Function Stack "
! Lexical Scoping "
!
"
! Bitwise Operators

Strict Mode "

! Built-in Functions "
! Closures "
!
"
! Logical Operators

"
! BigInt Operators Function Borrowing "
! in a method "
!

"
! String Operators in a function "
!
Using (this) keyword ____ "
!
"
! Conditional Operators using it alone "
!

"
! Comma Operators Explicit Binding "
! in event handlers "
!

"
! Unary Operators in arrow functions "
!
call apply bind
"
! Relational Operators Event Loop "
!

"
! setTimeout Callbacks "
! Callback Hell "
!
Asynchronous JavaScript "
!
"
! setInterval Promises "
! async / await "
!

"
! Iterators and Generators Classes "
!
"
! CommonJS
Modules in JavaScript "
!
"
! ECMAScript Modules Memory Lifecycle "
!
"
! Memory Management
Garbage Collection "
!

Debugging Issues "

!

"
! Using Chrome Dev Tools Debugging Memory Leaks "
!
Debugging Performance "
!

For ecosystem and more, check other tracks involving JavaScript

Frontend Roadmap Backend Roadmap

 Find the detailed version of this roadmap
!
" Beginner Topics / start with these
along with resources and other roadmaps
"
! Intermediate Topics / pick them after beginner topics

"
! Advanced Topics / pick these after intermediate topics Node.js http : // roadmap.sh

Backend roadmap till Language Selection

What is Node.js? JavaScript Roadmap

Node.js vs Browser
Why use Node.js? Introduction to Node.js
Running Node.js Code
History of Node.js

Global Installation
Common JS Creating Custom Modules
Modules Local Installation
ESM global Keyword
Installing Packages
Common Formats
npx
Updating Packages

Private Packages Using Installed Packages

Creating Packages npm
Public Packages Running Scripts

Uncaught Exceptions npm workspaces

JavaScript Errors

System Errors Call Stack & Stack Trace

Types of Errors Error Handling
User Specified Errors Debugging Node.js

Assertion Errors
Handling Async Errors
process.cwd() glob globby

Event Emitter path module fs-extra chokidar

Promises
Event Loop fs module OpenSource Packages
async / await

Callbacks Asynchronous Programming

Working with Files

setTimeout

setInterval dotenv package process.env __dirname

setImmediate Exitting & Exit Codes Environment Variables __filename

process.nextTick

Writing Async Code Command Line Apps Command Line Args

Printing Output Taking Input process.argv

fastify framework

Commander.js Package
Nestjs framework
process.stdout process.stdin

Express.js framework
process.stderr Prompts package http module
http module
chalk package Inquirer package axios package
HTTP Server
figlet package unfetch package

cli-progress package got package

Working with APIs

Making API Calls

nodemon package Keeping Application Running

jsonwebtoken package
ejs pug marko Templating Engines
Passport.js package
Knex package
Authentication

TypeORM package
Mongoose package

Sequelize package
Prisma package Document Working with Databases Relational

Prisma package
Native Drivers

Morgan Native Drivers

Jest

Mocha Testing Logging Winston

Cypress Keeping App Running pm2 Package

forever Package

Child Process Cluster Worker Threads

nohup

Garbage Collection
Threads
fs os net

path url Streams More Debugging Memory Leaks

events http node --inspect

Common Built-in Modules

console assert Using APM

process cluster

perf_hooks

crypto
Backend roadmap after Language Selection

Bu!er

Built-in Modules
 Find the detailed version of this roadmap
Related Roadmaps along with resources and other roadmaps


 Backend Roadmap
https : // roadmap.sh
DevOps Roadmap Backend roadmap till Language Selection



 Software Design Roadmap


 Important Note / Click here

Python
Basic Syntax Type Casting, Exceptions

Variables and Data Types Learn the Basics Functions, Builtin Functions

Conditionals Lists, Tuples, Sets, Dictionaries

RegEx
Datastructures and Algorithms
Iterators
Decorators

Lambdas Arrays and Linked Lists

Advanced Topics Heaps, Stacks and Queues

OOP

Classes Hash Tables

Inheritance Modules Binary Search Trees

Methods, Dunder Builtin Recursion

Custom Sorting Algorithms

Package Managers

PyPI Django

Pip Flask

Conda Pyramid Synchronous

Learn a Framework FastAPI

List Comprehensions

Generator Expressions
gevent Asynchronous
Paradigms
aiohttp

Tornado

doctest
Sanic

nose

pytest

Testing your Apps

unittest / pyUnit

For ecosystem and more, check other tracks involving Python

Backend Roadmap DevOps Roadmap

 Find the detailed version of this roadmap

 Personal Recommendation / Opinion
along with resources and other roadmaps

 Alternative Option - Pick this or purple


 Order in roadmap not strict (Learn anytime)
React https : // roadmap.sh
 I wouldn't recommend

Visit JavaScript Roadmap 

 Important Note / Click here


 Vite Class Components


 Create React App CLI Tools Components Functional Components 


Components Basics
Component Life Cycle
JSX
Lists and Keys

 Recoil Props vs State
Rendering
Render Props

 MobX
Conditional Rendering
Refs

 Redux / Toolkit
Composition
Events

 Zustand


 Context High Order Components
Basic Hooks

useState

State Management Routers Hooks

useE!ect

Emotion 
 
 React Router Writing Custom Hooks

Remix 

Styled Components 
 
 Reach Router
Common Hooks
Next.js 

useCallback useRef
Styling Mantine 

useMemo
Frameworks
Tailwind 

useReducer
Material UI 

useContext .......
Chakra UI 

Apollo 

Relay 


 Jest Vitest 

Urql 

GraphQL 
 React Testing Library

Forms
API Calls Testing

REST
Cypress 
 React Hook Form 


SWR 
 Playwright 
 Formik 


react-query 
 Final Form 

React Native
Axios 
 Suspense

superagent 
 Mobile Portals

Error Boundaries

Fiber Architecture

Advanced Topics

Visit the Frontend Developer Roadmap for more

Frontend Roadmap
Other Relevant Roadmaps Find the detailed version of this roadmap
PostgreSQL Roadmap along with resources and other roadmaps

Backend Developer Roadmap https : // roadmap.sh

SQL
Truncate Table

What are Relational Databases?

Alter Table
RDBMS Benefits and Limitations
Create Table
Introduction SQL vs NoSQL Databases

Data Definition Language (DDL) Basic SQL Syntax SQL keywords

Data Types

Data Manipulation Language (DML) SELECT Operators

FROM WHERE
SELECT INSERT
ORDER BY GROUP BY

HAVING JOINs UPDATE DELETE

SUM COUNT
Statements
AVG MIN MAX INSERT UPDATE DELETE

SELECT

Aggregate Queries Data Constraints JOIN Queries

GROUP BY Primary Key INNER JOIN

HAVING Foreign Key LEFT JOIN

Unique RIGHT JOIN

Creating Views NOT NULL FULL OUTER JOIN

Views Modifying Views CHECK Self Join Cross Join

Dropping Views

Scalar Column

CONCAT LENGTH Row Table

SUBSTRING REPLACE FLOOR ABS MOD Types of Sub Queries

UPPER LOWER ROUND CEILING Nested Subqueries Sub Queries

String Functions Numeric

Correlated Subqueries

Advanced SQL Functions

Date and Time Conditional Data Integrity and Security Data Integrity Constraints

DATE TIME CASE NULLIF

GRANT and REVOKE
DATEPART DATEADD COALESCE
Database Security Best Practices
TIMESTAMP

BEGIN
Stored Procedures and Functions
Managing Indexes
COMMIT
Indexes
Performance Optimization
Query Optimization
ROLLBACK

ACID SAVEPOINT Query Optimization Techniques

Using Indexes

Transactions Optimizing Joins

Reducing Subqueries

Transaction Isolation Levels

Selective Projection

Query Analysis Techniques

Advanced SQL Concepts

Recursive Queries Row_number

Pivot and Unpivot Operations rank

Window Functions dense_rank

CTEs (Common Table Expressions) lead lag

Dynamic SQL

Also visit the other relevant roadmaps.

Backend Roadmap PostgreSQL Roadmap