Wiki Nzar Dev Logo

The Full Journey

Track and explore the full roadmap, see what's already covered, what's actively being worked on, and what's coming. A clear vision of where we've been and where we're going. 13 of 466 topics completed. Click any card to explore more.

How a Computer Works: CPU, RAM, Storage & I/O
How Operating Systems Work: Processes, Threads & Memory
How File Systems Work
How Networking Works: IP, DNS, TCP/UDP, HTTP
How the Internet Works: Routers, Packets & Protocols
How Browsers Work: Parsing, Rendering & the DOM
How Web Applications Work: Client ↔ Server Model
How Servers Work: What Happens When You Hit a URL
Binary, Hexadecimal and How Computers Store Data
The Abstraction Ladder: Hardware → OS → Runtime → App
What Software Engineering Actually Is
Problem Decomposition: Breaking Big Problems Into Small Ones
How to Read Documentation Like a Pro
How to Debug Systematically (Not by Guessing)
Understanding Errors: Reading Stack Traces & Logs
Using AI Tools Effectively (Without Becoming Dependent)
Version Control Philosophy: Why We Track Everything
The Importance of Writing Clean, Readable Code
How to Search for Answers (Stack Overflow, GitHub, Docs)
Building a Learning System That Compounds Over Time
HTML Cheat Sheet & Document Structure
Every HTML Tag You Actually Need to Know
Semantic HTML: Why Structure Matters
Forms: Inputs, Validation, Labels & Accessibility
Tables: When and How to Use Them
Metadata & SEO: head, title, og tags, robots
HTML Accessibility: ARIA Roles, Screen Readers, Alt Text
Embedding: iframes, video, audio, SVG
Web Components: Custom Elements Overview
HTML Email: Why It's Still Hell
CSS Cheat Sheet & The Cascade Explained
Selectors, Specificity and Inheritance
The Box Model: Margin, Padding, Border
Flexbox: Complete Visual Guide
CSS Grid: Complete Visual Guide
Responsive Design: Media Queries & Mobile First
CSS Variables and Custom Properties
Animations & Transitions: Keyframes and Timing Functions
Pseudo-classes and Pseudo-elements
CSS Architecture: BEM, SMACSS, Utility-First
TailwindCSS: Setup, Configuration & Real Usage
CSS Modules: Scoped Styles Without a Runtime
Dark Mode Implementation
Performance: Render Blocking, Paint Layers, will-change
JavaScript Cheat Sheet
Variables: var, let, const and Hoisting
Data Types, Type Coercion and typeof
Operators, Expressions and Control Flow
Functions: Declarations, Expressions, Arrow Functions
Scope, Closures and the Lexical Environment
The Prototype Chain and Inheritance
Object-Oriented Programming in JavaScript (Classes & Prototypes)
DOM Manipulation: Selecting, Creating, Modifying Elements
Events: Bubbling, Capturing, Delegation
The Event Loop: Call Stack, Microtasks, Macrotasks
Asynchronous JS: Callbacks → Promises → Async/Await
Fetch API & Working with HTTP Requests
Error Handling: try/catch, Error Types, Custom Errors
ES6-ES2024 Features You Must Know
Modules: ESM vs CommonJS
Memory Management and Garbage Collection
JavaScript in the Browser vs Node.js
Web APIs: localStorage, sessionStorage, Clipboard, Geolocation
Regular Expressions in JavaScript
Why DSA Matters for Real Engineering
Big O Notation: Time and Space Complexity
Arrays and Dynamic Arrays
Linked Lists: Singly, Doubly, Circular
Stacks and Queues
Hash Maps and Hash Sets
Trees: Binary Trees, BSTs, Balanced Trees
Graphs: Representations, BFS, DFS
Heaps and Priority Queues
Sorting Algorithms: Bubble, Merge, Quick, Radix
Searching Algorithms: Binary Search
Recursion and Divide & Conquer
Dynamic Programming: Memoization & Tabulation
Greedy Algorithms
Sliding Window & Two Pointer Patterns
Solving LeetCode Problems Systematically
TypeScript Cheat Sheet
Why TypeScript: The Case for Static Typing
Types vs Interfaces: When to Use What
Primitive Types, Union, Intersection and Literal Types
Enums: Numeric, String and Const Enums
Generics: Writing Reusable, Type-Safe Code
Utility Types: Partial, Required, Pick, Omit, Record, ReturnType
Type Narrowing and Type Guards
Mapped Types and Conditional Types
Decorators and Metadata Reflection
Module Augmentation and Declaration Merging
tsconfig.json: Every Option Explained
TypeScript with React: Props, Events, Refs
TypeScript with Node.js and Express
Working with External APIs Using Types
Advanced Patterns: Builder, Branded Types, Infer
Git Core Concepts: Repository, Commit, Staging
Branching: Creating, Switching, Merging
Rebasing: Interactive Rebase and History Cleanup
Cherry-picking Commits
Resolving Merge Conflicts Like a Pro
Git Stash, Reflog and Recovery
GitHub & GitLab: Pull Requests, Issues, Reviews
Conventional Commits and Semantic Versioning
Git Tags and Release Management
Monorepos: Turborepo and Nx
Git Submodules and Git Worktrees
Git Hooks with Husky and lint-staged
GitHub Actions: Your First Workflow
Terminal & Shell: Bash, Zsh, Fish Basics
Useful CLI Tools Every Dev Should Know
npm vs yarn vs pnpm: Differences and When to Use Each
package.json Deep Dive: Scripts, Peers, Workspaces
Bundlers: Vite, Webpack, esbuild, Rollup Compared
Transpilers: Babel and SWC Explained
Linting with ESLint: Config, Rules, Plugins
Formatting with Prettier: Setup and Integration
Editor Setup: VSCode Extensions for Productivity
Environment Variables: .env, dotenv, Secret Management
Path Aliases and Module Resolution
React Cheat Sheet
Why React: The Component Model Philosophy
JSX: What It Actually Compiles To
Props, State and the Rendering Model
The Virtual DOM and Reconciliation
useState and useReducer
useEffect: Side Effects, Cleanup and Dependencies
useRef: DOM Access and Persistent Values
useMemo and useCallback: When and Why
Custom Hooks: Extracting and Sharing Logic
Context API: Global State Without a Library
React Router v6: Layouts, Loaders, Actions
Forms: Controlled vs Uncontrolled Inputs
React Hook Form and Zod Validation
Portals, Suspense and Error Boundaries
Performance: Profiling, Virtualization, Memoization
React 19: New Hooks, Server Components, Actions
Testing React Components with Testing Library
Vue 3 vs React: Core Differences and Mental Model
Vue 3 Basics: Composition API, Reactivity, Templates
Svelte: How It Works Without a Virtual DOM
Svelte Basics: Stores, Reactivity, Transitions
When to Pick Vue or Svelte Over React
Local State vs Global State vs Server State
When NOT to Use Global State
Context API: Patterns and Pitfalls
Zustand: Simple Global State That Scales
Redux Toolkit: Actions, Slices, Thunks, DevTools
Jotai and Recoil: Atomic State Model
TanStack Query: Fetching, Caching, Syncing Server State
Optimistic Updates and Background Refetching
State Machines with XState
Choosing the Right State Tool for the Right Problem
Folder Structure Patterns for Scale
Feature-Sliced Design Architecture
Design Systems: Building Component Libraries
Storybook: Developing and Documenting Components in Isolation
Visual Regression Testing with Chromatic and Percy
Compound Component Pattern
Render Props and Higher-Order Components
Headless UI: Radix, Headless UI, Ariakit
Accessibility in Real Applications (Beyond the Basics)
Internationalization (i18n) with react-i18next
Frontend Performance: Core Web Vitals in Practice
Code Splitting, Lazy Loading and Bundle Analysis
Web Workers for Offloading Heavy Computation
Progressive Web Apps (PWA): Service Workers, Manifest, Offline
Next.js Architecture: How It Works Under the Hood
App Router vs Pages Router: A Complete Comparison
File-Based Routing: Layouts, Pages, Loading, Error
Server Components vs Client Components: The Mental Model
Data Fetching: fetch(), cache(), and revalidate
SSR, SSG, ISR and CSR — Choosing the Right Strategy
Server Actions: Forms and Mutations Without an API
API Routes: Building Endpoints Inside Next.js
Middleware: Auth Guards, Redirects, Geo-Routing
Edge Runtime vs Node.js Runtime
Image Optimization with next/image
Font Optimization with next/font
Metadata API and Dynamic SEO
Caching, Revalidation and the Next.js Cache Model
Streaming and Suspense in the App Router
Deployment on Vercel vs Self-Hosted
Internationalization with Next.js
Remix vs Next.js: When to Pick Which
Remix Core Concepts: Loaders, Actions, Forms
Nested Routing and Layout Nesting in Remix
Error Boundaries and CatchBoundaries in Remix
Remix Deployment: Vercel, Fly.io, Cloudflare Pages
Relational vs Non-Relational: How to Choose
SQL Fundamentals: SELECT, INSERT, UPDATE, DELETE
Joins: INNER, LEFT, RIGHT, FULL, CROSS
Subqueries, CTEs and Window Functions
PostgreSQL: Setup, Config and Advanced Features
MySQL: Differences from PostgreSQL
MongoDB: Document Model, Collections, Queries
SQLite for Local and Edge Use Cases: Turso, Cloudflare D1
Database Design: Normalization (1NF, 2NF, 3NF)
Entity-Relationship Diagrams (ERDs)
Indexing: B-Tree, Hash, Partial, Composite Indexes
Query Optimization and EXPLAIN ANALYZE
ACID Properties and Transactions
Concurrency: Locks, Deadlocks, Isolation Levels
Redis: Caching, TTL, Pub/Sub, Sorted Sets
Database Migrations: Strategy and Best Practices
Backups, Replication and High Availability
Choosing the Right Database for the Right Problem
ORMs vs Query Builders vs Raw SQL: Trade-offs
Prisma: Schema-First ORM Setup
Prisma: Relations, Nested Writes, Transactions
Prisma: Migrations Workflow
Drizzle ORM: Schema Definition and Type Safety
Drizzle: Migrations and Drizzle Studio
Kysely: Type-Safe Query Builder
Connection Pooling with PgBouncer and Prisma Accelerate
N+1 Query Problem and How to Fix It
Seeding Databases for Development and Testing
How HTTP Really Works: Methods, Headers, Status Codes, Body
The Request Lifecycle in a Node.js Server
Node.js Runtime: Event Loop Deep Dive
Node.js Streams and Buffers
Node.js Worker Threads and Child Processes
Express.js: Routing, Middleware, Error Handling
Fastify: Performance-First Alternative to Express
Hono: Edge-Ready Lightweight Framework
REST API Design: Principles, Conventions, Versioning
CRUD Operations and Resource Modeling
Request Validation with Zod
File Uploads: Multipart, S3 Pre-signed URLs
Pagination: Cursor-Based vs Offset-Based
Rate Limiting and Throttling
Logging with Pino and Winston
Error Handling Architecture
Background Jobs with BullMQ and Redis
Scheduled Tasks with Cron
Email Sending: Nodemailer, Resend, Postmark
Authentication vs Authorization: The Difference
Sessions and Cookies: How They Work
JWT: Structure, Signing, Verification, Expiry
OAuth 2.0: The Full Flow Explained (Authorization Code, PKCE)
OpenID Connect and Identity Tokens
Auth.js (NextAuth): Setup, Providers, Callbacks
Clerk: Managed Auth with Advanced Features
Lucia Auth: Lightweight DIY Auth
Implementing RBAC: Roles, Permissions, Policies
Multi-Factor Authentication: TOTP, WebAuthn, Passkeys
Password Hashing: bcrypt, argon2, scrypt
Refresh Tokens and Token Rotation
Auth Security: Timing Attacks, Brute Force, Account Takeover
API Key Management and Hashed Storage
REST API Best Practices: Naming, Status Codes, Errors
API Documentation with OpenAPI and Swagger UI
GraphQL: Schema, Resolvers, Queries, Mutations
GraphQL: DataLoader, N+1, Subscriptions
tRPC: End-to-End Type Safety Without a Schema
gRPC: Protocol Buffers, Services and Use Cases
WebSockets: Full-Duplex Communication
Socket.io: Rooms, Namespaces, Broadcasting
Server-Sent Events (SSE) for Streaming Data
Webhooks: Receiving, Validating and Retrying
API Versioning Strategies
API Gateway Pattern
Rate Limiting and Quota Design
The Testing Pyramid: Unit, Integration, E2E
What Makes Code Testable
Vitest: Setup, Config, Matchers
Jest vs Vitest: Differences and Migration
Unit Testing Pure Functions and Utilities
Mocking: Modules, APIs, Timers and Dates
React Testing Library: Queries, Events, Async
Testing Custom Hooks
Integration Testing: Testing API + Database Together
Contract Testing with Pact
Test-Driven Development (TDD) in Practice
Code Coverage: Istanbul, V8 and What to Actually Measure
Snapshot Testing: When It Helps and When It Hurts
Playwright: E2E Tests, Selectors, Assertions
Cypress: Alternative E2E with Time Travel Debugging
Visual Regression Testing with Chromatic and Percy
Testing in CI: Running Tests on Every Push
Parallelizing Tests for Faster Pipelines
Performance Testing and Load Testing (k6)
Linux File System Hierarchy
Essential Linux Commands Every Dev Must Know
File Permissions: chmod, chown, umask
Process Management: ps, kill, top, systemd
Networking Commands: curl, wget, netstat, ss, dig, ping
SSH: Key Generation, Config, Tunneling, Reverse Proxies
Cron Jobs and Scheduled Tasks
Shell Scripting: Bash Variables, Loops, Functions
Package Managers: apt, yum, brew
Environment Variables and Shell Config (.bashrc, .zshrc)
Text Processing: grep, awk, sed, jq
Log Viewing: tail, journalctl, less
Why Docker: The Problem It Solves
Images vs Containers vs Registries
Writing a Dockerfile: FROM, RUN, COPY, CMD, ENTRYPOINT
Dockerfile Best Practices: Layer Caching, Multi-Stage Builds
Docker Compose: Multi-Container Applications
Volumes and Bind Mounts
Networking Between Containers
Environment Variables in Docker
Publishing to Docker Hub and GitHub Container Registry
Docker in Development vs Production
Debugging Containers: exec, logs, inspect
What is CI/CD and Why It Matters
GitHub Actions: Syntax, Events, Jobs, Steps
Building a CI Pipeline: Lint, Test, Build
Building a CD Pipeline: Deploy on Merge
Matrix Builds and Parallelism
Caching Dependencies in GitHub Actions
Secrets Management in Pipelines
Environments: Preview, Staging, Production
Release Automation with Changesets and Semantic Release
GitLab CI: Equivalent Concepts
Blue/Green and Canary Deployments
Cloud Computing Models: IaaS, PaaS, SaaS, FaaS
AWS Core Services: EC2, VPC, IAM, S3, RDS, CloudFront
AWS Lambda and Serverless Architecture
Google Cloud Platform: GCS, Cloud Run, Firebase
Azure: App Service, Functions, Blob Storage
CDN and Edge Networks: Cloudflare, Fastly
DNS Management and Domain Configuration
Load Balancers: ALB, Nginx, Caddy
Nginx as a Reverse Proxy: SSL, proxy_pass, Caching Headers
Infrastructure as Code with Terraform
Kubernetes: Pods, Deployments, Services, Ingress
Managed Kubernetes: EKS, GKE, AKS
Secrets Management: AWS Secrets Manager, Vault
Cost Optimization in the Cloud
Networking Fundamentals: OSI Model, IP, TCP, UDP
TLS/SSL: Certificates, Handshake, HTTPS
DNS Deep Dive: Records, TTL, CDN Setup
Firewalls, Proxies and Reverse Proxies
OWASP Top 10: The Most Critical Security Risks
SQL Injection: Attack and Defense
XSS (Cross-Site Scripting): Types, Payloads, Prevention
CSRF: How It Works and How to Prevent It
Clickjacking and Frame Busting
Content Security Policy (CSP) in Depth
Secure HTTP Headers: HSTS, X-Frame-Options, CORP, COEP
Rate Limiting and DDoS Mitigation
Dependency Vulnerabilities: npm audit, Snyk, Dependabot
Secrets Scanning and Credential Leak Prevention
Subdomain Takeover: How It Happens and How to Prevent It
Supply Chain Attacks: What They Are and How to Defend
Penetration Testing Basics
Security Headers Checklist for Production Apps
React Native vs Expo: Which to Use
How React Native Works Under the Hood (New Architecture)
Core Components: View, Text, Image, ScrollView, FlatList
Navigation with Expo Router and React Navigation
Styling in React Native: StyleSheet vs NativeWind
Device APIs: Camera, GPS, Notifications, Contacts
Animations with Reanimated 3
Gestures with React Native Gesture Handler
State Management in React Native Apps
Offline Support and Local Storage (MMKV, SQLite)
Push Notifications with Expo and Firebase
App Store and Play Store Submission
Over-the-Air Updates with Expo EAS
React Native vs Flutter: A Comparison
Desktop App Options: Electron vs Tauri — How to Choose
Electron: Architecture, Main vs Renderer Process
Electron: IPC Communication and Security
Tauri: Rust-Powered Lightweight Alternative to Electron
Native OS Integration: File System, Tray, Notifications
Auto-Updates and Distribution
Packaging for Windows, macOS and Linux
Performance Considerations in Desktop Apps
When to Build Desktop vs Web
Core Web Vitals: LCP, CLS, INP — What They Mean in Practice
Browser Performance: Render Blocking, Paint, Compositing
JavaScript Performance: Profiling in Chrome DevTools
React Performance: Memo, Virtualization, Profiler
Bundle Analysis: Finding and Eliminating Bloat
Image Optimization: Formats, Sizes, Lazy Loading
Font Loading Strategies
Database Performance: Query Plans, Index Usage
Caching Strategies: Browser, CDN, Server, Application
HTTP/2 and HTTP/3: Multiplexing and QUIC
Edge Computing and Latency Optimization
Profiling Node.js: CPU Profiles and Heap Snapshots
The Three Pillars: Logs, Metrics, Traces
Structured Logging with Pino
Distributed Tracing with OpenTelemetry
Error Tracking with Sentry: Setup and Source Maps
Uptime Monitoring: Better Uptime, Checkly
Metrics Collection with Prometheus
Dashboards with Grafana
Alerting: When and What to Alert On
Log Aggregation: Loki, Datadog, Logtail
APM Tools: Datadog APM, New Relic
Health Check Endpoints and Readiness Probes
On-Call Practices and Incident Response
How to Approach a System Design Problem
Scalability: Vertical vs Horizontal Scaling
Load Balancing: Algorithms and Strategies
Caching at Every Layer: CDN, Reverse Proxy, App, DB
Database Scaling: Read Replicas, Sharding, Partitioning
CAP Theorem and Consistency Trade-offs
Message Queues: Kafka, RabbitMQ, SQS
Event-Driven Architecture and CQRS
Microservices vs Monolith: Trade-offs in Depth
API Gateway and Service Mesh (Istio, Kong)
Rate Limiting at Scale
Designing for Failure: Circuit Breakers, Retries, Timeouts
Real-World Architectures: Netflix, Uber, WhatsApp
Designing a URL Shortener
Designing a Chat System
Designing a Social Feed
Designing a Notification System
SOLID Principles With Real Code Examples
DRY, KISS, YAGNI: When Rules Conflict
Design Patterns: Creational (Factory, Builder, Singleton)
Design Patterns: Structural (Adapter, Decorator, Proxy, Facade)
Design Patterns: Behavioral (Observer, Strategy, Command, Iterator)
MVC, MVP, MVVM: Frontend and Backend Variants
Repository Pattern and Data Abstraction
Service Layer and Use Cases
Domain-Driven Design (DDD): Entities, Aggregates, Repositories
Clean Architecture: Dependency Rule and Layer Separation
Event Sourcing and CQRS
Monorepo Architecture: Turborepo, Nx
How Large Language Models Work (Without the Math)
Tokens, Context Windows and Temperature
OpenAI API: Chat, Completions, Vision, Embeddings
Anthropic API: Claude and the Messages Format
Prompt Engineering: System Prompts, Roles, Few-Shot
Streaming Responses in Web Apps
Vercel AI SDK: useChat, useCompletion, Server-Side Streaming
Function Calling and Tool Use
Structured Output with JSON Mode and Zod
RAG: Retrieval-Augmented Generation Architecture
Vector Embeddings and Similarity Search
Vector Databases: Pinecone, pgvector, Qdrant
Building AI Agents: Memory, Tools, Loops
LangChain and LlamaIndex Overview
Fine-Tuning vs Prompting: When to Use Each
AI Output Validation: Hallucination Handling and Guardrails in Production
Cost Optimization for AI Features
How to Read and Navigate a Large Codebase
Finding Your First OSS Contribution
Making a Good Pull Request
Writing Useful Issues and Bug Reports
Maintaining Your Own Open Source Project
Semantic Versioning and Changelogs
Publishing npm Packages
Building a Developer Brand on GitHub
Technical Writing and Documentation
Clean Code in Practice: Naming, Functions, Comments
Code Review: How to Give and Receive Feedback
Working in a Team: PRs, Async Communication and Collaboration
Technical Documentation: ADRs, RFCs, READMEs
Debugging Systematically: Reproducing, Isolating, Fixing
On-Call and Production Incident Response
Agile and Scrum: How Real Teams Work
Engineering Estimation: Story Points and T-Shirt Sizing
Writing a Resume That Gets Past ATS
Building a Portfolio That Stands Out
Technical Interview Preparation: Coding, System Design, Behavioral
How to Evaluate a Job Offer
Career Paths: IC vs Engineering Manager
Freelancing and Consulting as an Engineer
Building in Public: Twitter, LinkedIn, YouTube
The Compound Effect: Learning Systems for Long-Term Growth