FAANG-Level Engineering Transformation

From Legacy PHP Dev
to Elite Engineer

A brutally practical, step-by-step roadmap to transform your skills, rebuild your fundamentals, and become a globally competitive software engineer — without AI dependency.

365Days to Transform
20+Skill Tracks
500+Practice Problems
15+Build Projects
∞Growth Potential
01

Current Situation Analysis

An honest, mentor-level diagnosis of where you stand right now.

The Real Problem
You have 3 years of experience but you've been building usage hours, not engineering skills. AI tools helped you ship code faster, but they also prevented you from building the mental models that senior engineers rely on. The good news: your exposure to PHP, MySQL, Laravel, CouchDB, and deployment gives you a valuable foundation to build upon — not start over.

Strengths (Don't Discount These)

✅ Real Production Experience
You've deployed to live servers, handled real databases, touched real users. Most bootcamp grads haven't. This is gold.
✅ Multi-Stack Exposure
PHP + Laravel + MySQL + CouchDB + JS + Git = You understand different paradigms. SQL vs NoSQL. Relational vs document models.
✅ Business Context
Working with legacy ERP systems means you understand how real businesses run. This is rare among junior developers.
✅ Self-Awareness
Most weak engineers don't know they're weak. You do. That metacognition is the first step to real mastery.

Biggest Problems — Brutally Honest

❌ Passive Code Consumption
You've been reading and modifying AI code instead of writing from scratch. This is like watching someone else work out and expecting to get fit. Muscle memory doesn't form this way.
❌ No Mental Models
When AI gives you code, you don't build the "why" — only the "what". Mental models (how memory works, how HTTP works, how trees traverse) are what senior engineers use to solve new problems instantly.
❌ Weak Debugging Loop
Real debugging requires: hypothesis → test → analyze → repeat. AI shortcuts this loop. You never built the neurological pathway that makes debugging feel like detective work.
❌ Zero Algorithmic Thinking
Without DSA practice, you can't answer: "Is this O(n²)? Can I make it O(n log n)?" These questions decide whether your app survives 100k users or dies at 1000.
❌ Confidence Erosion
Every time you couldn't solve something without AI, your brain recorded "I can't do this". You now have imposter syndrome baked in. This needs systematic rebuilding through small daily wins.
❌ Legacy-Only Mindset
PHP 5.6 patterns are anti-patterns today. Global functions, no type safety, procedural code — these habits slow you down when writing modern PHP 8+ or TypeScript.
02

Mindset Reset

Before a single line of code, fix the software running between your ears.

The New Rules

  • Struggle is the curriculum. When you feel stuck and frustrated, that's not failure — that's myelination. Your brain is literally rewiring. Embrace it.
  • Understanding > Completion. A slow, deeply understood solution beats a fast, copy-pasted one. Every time.
  • Write code before reading solutions. Spend at least 25-45 minutes genuinely attempting every problem before looking at hints. This is non-negotiable.
  • Read documentation like a senior. Not Googling "how to do X" — reading the official docs to understand the full API surface area.
  • Own your learning pace. Compare yourself to past-you, not YouTube tutorial creators. They've been doing this for 10+ years.
  • AI is a calculator, not a teacher. You wouldn't use a calculator to learn multiplication tables. Use AI to check, not to create.
  • Identity shift: Stop saying "I'm a PHP developer." Say "I'm a software engineer who currently uses PHP." Huge difference in trajectory.
  • The 2% rule: Get 2% better every day. In 1 year, you're 1300% better. Daily discipline beats motivation every time.

Deep Work Protocol

The Focus System

Based on Cal Newport's Deep Work + Andela engineering practices:

  • Block 2-3 hours of uninterrupted coding daily — phone in another room
  • Use Pomodoro: 50 min work → 10 min break
  • Write code in the morning (peak cognitive hours)
  • No social media during study blocks — use Cold Turkey or Freedom app
  • Keep a "distraction log" — write the thought down, return to focus
  • End every session writing what you learned in 3 sentences
Note-Taking System (Zettelkasten + Code Journal)
  • Use Obsidian (free) — link concepts together like a second brain
  • For each new concept: What is it? Why does it exist? How does it work? When to use it?
  • Keep a "bugs solved" journal — write the problem, your hypothesis, the solution
  • Weekly review: re-read your notes from the past 7 days in 15 min
  • Code snippets go in a personal wiki repo on GitHub — your living cheatsheet
03

30-Day Recovery Plan

Rebuild fundamentals. No frameworks. No AI. Just you and the terminal.

⚠ The Hard Rule for Month 1
No Laravel. No frameworks. No AI code generation. PHP from scratch, JavaScript from scratch, SQL from scratch. This is detox month. It feels brutal. It's worth it.
Week 1 — Days 1–7
Core Programming Fundamentals Recovery
Treat this like Day 1 of engineering school. Go back to the absolute basics and do them properly this time.
  • Variables, data types, type coercion — write 20 small programs to test your understanding
  • Control flow: if/else, switch, loops — solve 30 HackerRank easy problems without AI
  • Functions: parameters, return values, scope, closures — write a mini calculator in both PHP and JS from memory
  • Arrays: create, search, sort, filter — implement these manually without built-in functions
  • Strings: manipulation, regex basics — solve 15 string problems on LeetCode (easy tier)
  • Read: "PHP: The Right Way" (phptherightway.com) — chapters 1-4
  • Goal: Write a CLI address book app in pure PHP — no framework, from scratch
Week 2 — Days 8–14
OOP + Data Structures Introduction
Object-Oriented Programming done right — not copy-pasted, but genuinely understood.
  • Classes, objects, methods, properties — understand why OOP exists, not just how
  • Inheritance, interfaces, abstract classes — the SOLID principles (1 per day)
  • Implement a Stack and Queue from scratch in PHP — no built-in data structures
  • Implement a Linked List from scratch — add, delete, search, reverse
  • Read: "Clean Code" by Robert Martin — chapters 1-5 (get PDF from archive.org)
  • LeetCode: 5 easy array problems, 5 easy string problems, 3 easy linked list problems
  • Goal: Build a small OOP inventory system in PHP — Product, Category, Inventory classes
Week 3 — Days 15–21
Database Fundamentals + SQL Mastery
SQL is a superpower. Most developers treat it like CRUD syntax. Learn it like a data architect.
  • Install MySQL locally — no GUI tools this week, only terminal
  • Create databases, tables, relationships — foreign keys, indexes, constraints by hand
  • Master JOINs: INNER, LEFT, RIGHT, FULL, SELF — write 20 JOIN queries on a sample db
  • Aggregations: GROUP BY, HAVING, window functions — understand when each is appropriate
  • Subqueries vs JOINs — understand the performance difference with EXPLAIN
  • Normalization: 1NF, 2NF, 3NF — design a schema for a school management system
  • Practice: SQLZoo.net, Mode Analytics SQL Tutorial (both free)
  • Goal: Build and query a full e-commerce database schema from memory
Week 4 — Days 22–30
JavaScript Fundamentals + HTTP/Web Fundamentals
Understand the web at the protocol level. Know what happens when you press Enter in a browser.
  • JavaScript: var/let/const, closures, prototype chain, this keyword — no frameworks
  • Async: callbacks → promises → async/await — implement a fake API call chain manually
  • HTTP: request/response cycle, verbs (GET/POST/PUT/DELETE/PATCH), headers, cookies, sessions
  • Build a raw PHP server (no framework) that handles REST API routes manually
  • JSON: encoding, decoding, validation — build a simple JSON API by hand
  • DOM: querySelector, events, createElement, fetch API — build a todo app in vanilla JS
  • Goal: A working REST API in raw PHP + a vanilla JS frontend consuming it
✅ Month 1 Success Metrics
You should be able to: write a functioning PHP class from memory, explain the difference between JOIN types, implement a linked list without Googling, and build a basic REST API endpoint without any framework. If you can do these, month 2 begins.
04

90-Day Intensive Plan

DSA foundation, modern PHP/Laravel, React fundamentals, and first real projects.

Month 2: DSA + Laravel Mastery

DSA: Daily 1 Problem Habit

Weeks 5-6 focus areas:

  • Arrays: Two pointers, sliding window technique — 20 problems
  • Binary search: standard + variations — 10 problems
  • Recursion: base case thinking, call stack visualization — 10 problems
  • Stacks + Queues: implement, apply — 10 problems
  • Big-O notation: analyze every solution you write
  • Platform: LeetCode (free), NeetCode.io for video explanations
Modern PHP + Laravel

Weeks 7-8 focus areas:

  • PHP 8.x: types, match, fibers, readonly, enums, named arguments
  • Laravel: routing, middleware, controllers, models — read official docs only
  • Eloquent ORM: relationships, eager loading, query builder
  • Artisan commands, migration system, seeder pattern
  • Authentication: Laravel Sanctum + Passport basics
  • Build: A blog system with auth, posts, categories, tags from scratch

Month 3: React + APIs + First Full Project

React Fundamentals
  • Understand the Virtual DOM — don't just use React, understand why it exists
  • useState, useEffect, useContext — master these 3 hooks before all others
  • Component design: props, lifting state, composition over inheritance
  • React Router — SPA routing patterns
  • Axios/Fetch: consuming Laravel APIs from React
  • Form handling with controlled components — no libraries first
  • Tailwind CSS: utility-first styling — productive within 1 week
First Real Project: Task Management System
  • Backend: Laravel API (auth, tasks CRUD, teams, assignments)
  • Frontend: React SPA consuming the API
  • Database: MySQL with proper relationships and indexes
  • Auth: JWT-based login/register flow
  • Deploy: Railway.app or Render.com (free tier)
  • GitHub: public repo with proper README, commit messages
  • This is your first portfolio piece — treat it seriously

90-Day Milestones

LeetCode easy solved
40/50
DSA topics covered
6/10
Laravel features mastered
7/10
Projects deployed
1-2
React hooks mastered
6/10
05

6-Month Transformation Plan

Intermediate DSA, system design intro, advanced backend, ERP modules, portfolio building.

Month 4
Intermediate DSA + Advanced Laravel
  • DSA: Trees (BFS/DFS), Binary Search Trees, Heaps — 30 medium problems
  • Laravel: Queues (Redis), Events, Listeners, Observers, Jobs
  • Caching strategy: Redis + Laravel Cache facade — implement in project
  • RESTful API design principles + OpenAPI/Swagger documentation
  • Service pattern, Repository pattern, Action classes in Laravel
  • Testing: PHPUnit + Feature tests for all API endpoints
  • Build: Multi-tenant SaaS skeleton — team management, plans, billing hooks
Month 5
System Design Basics + Database Optimization
  • System design: Load balancers, CDN, caching layers, message queues — draw diagrams
  • Database: Advanced indexing, EXPLAIN ANALYZE, query optimization, partitioning
  • MySQL: Replication concepts, read replicas, connection pooling
  • Redis: Data types (sets, sorted sets, hashes), pub/sub, TTL strategies
  • WebSockets: Laravel Echo + Pusher/Soketi for real-time features
  • Security: SQL injection, XSS, CSRF, OWASP Top 10 — protect your apps
  • Graphs DSA: BFS, DFS, Dijkstra, topological sort — 20 problems
Month 6
ERP Module Development + TypeScript + Portfolio
  • ERP modules: Build Inventory, Purchase Order, and Sales modules in Laravel
  • TypeScript: Migrate your React frontend to TS — understand type safety deeply
  • State management: Zustand (simpler) → Redux Toolkit (for complex apps)
  • Dynamic Programming intro: understand memoization, tabulation — 15 problems
  • Build portfolio project: Production-grade ERP module (inventory + sales + reports)
  • Open source: Find 2-3 PHP/Laravel packages, submit 1 PR to each
  • GitHub profile: polished READMEs, pinned repos, contribution graph active
06

1-Year Elite Engineer Plan

Advanced DSA, microservices, full system design, interview readiness, global job market.

Q3 Months 7-9
  • Advanced DSA: DP patterns (knapsack, LCS, matrix chain), Backtracking, advanced graphs
  • Design patterns: Factory, Strategy, Observer, Decorator, CQRS, Event Sourcing
  • Microservices: Docker containers, service communication, API gateway pattern
  • Message queues: RabbitMQ or Apache Kafka basics
  • LeetCode: 100+ mediums solved, 20+ hards attempted
  • First technical blog post published on dev.to or Medium
  • Complete ERP: Accounting module + Payroll module + HR module
Q4 Months 10-12
  • System design mock interviews: LLD + HLD — 20 practice sessions
  • DSA mock interviews: 3 per week on Pramp.com or Interviewing.io
  • Production deployment: Complete CI/CD pipeline, Docker Compose, Nginx
  • Performance: profiling PHP apps with Blackfire, Laravel Telescope, Debugbar
  • Complete SaaS product: ready to launch, with landing page and documentation
  • Resume polished, GitHub green, LinkedIn optimized for remote roles
  • Apply to 5 companies per week, track with Notion — aim for top product companies
07

Daily Routine

A concrete hour-by-hour schedule that builds the daily discipline of a senior engineer.

This is designed for someone working a job. If you're full-time on learning, double the deep work blocks. Consistency beats intensity — 3 hours daily beats 20 hours on Sunday.

Weekday Schedule

5:30
Wake. No phone. Write 3 goals for the day. Habit
5:45
LeetCode: 1 problem (30-40 min deep attempt — NO hints for first 25 min) DSA
6:30
Breakfast, shower, commute prep
7:00
Read technical book/doc (30 min) — not tutorials, actual books Theory
9:00
Work day begins (your current job)
13:00
Lunch: 30 min study break — review yesterday's notes in Obsidian
18:00
Evening deep work block starts — project building or backend track Build
20:30
Frontend practice or system design reading (lighter cognitive load)
21:30
Write in code journal: what did I build, debug, learn today?
22:00
Read (non-tech): biography, psychology, business — feeds problem-solving
22:30
Sleep. Non-negotiable. Cognitive performance requires 7-8 hrs.

Weekend Schedule (Full Learning Mode)

7:00
Wake. 2 LeetCode problems — one medium, one attempt at hard
9:00
2-hour deep project build session — no interruptions Build
11:00
Break + walk — movement improves creative problem solving
11:30
System design study: read 1 chapter of "Designing Data-Intensive Apps"
13:00
Lunch + rest
14:00
2-hour project build session — complex features, debugging Build
16:00
Weekly review: what did I learn? What's the plan for next week?
17:00
Open source: read issues, submit PRs, comment on discussions
18:00
Personal life, friends, family — burnout prevention is also strategy
09

DSA Mastery Roadmap

Complete Data Structures & Algorithms track with exact problems, patterns, and timeline.

DSA Philosophy
Don't grind 500 problems randomly. Master 15 patterns deeply — most interview problems are combinations of these patterns. Quality of understanding > quantity of problems.

Exact Learning Order (Follow This Strictly)

#TopicWeekEasyMedHardTotal
1Arrays + Basic MathWeek 5100010
2StringsWeek 58008
3Two PointersWeek 655010
4Sliding WindowWeek 637010
5Binary SearchWeek 758215
6RecursionWeek 755010
7Linked ListsWeek 857012
8Stacks + QueuesWeek 958013
9Trees (BFS/DFS)Week 10-11512320
10Binary Search TreeWeek 1146010
11Heaps / Priority QueueWeek 1237212
12Graphs (BFS/DFS)Week 13-14312318
13GreedyWeek 1537010
14BacktrackingWeek 1608412
15Dynamic ProgrammingWeek 17-205201035
Arrays + Two Pointers
Easy: 10 Med: 8
LC #1 Two Sum LC #26 Remove Dupes LC #121 Stock Buy/Sell LC #217 Contains Duplicate LC #238 Product Except Self LC #11 Container Water LC #15 3Sum LC #42 Trapping Rain Water LC #128 Longest Consecutive LC #167 Two Sum II
Sliding Window
Easy: 3 Med: 7 Hard: 2
LC #3 Longest Substring No Repeat LC #76 Minimum Window Substring LC #121 Best Time Stock LC #239 Sliding Window Maximum LC #424 Longest Repeating Char Replace LC #567 Permutation in String LC #643 Max Avg Subarray
Trees (BFS + DFS)
Easy: 6 Med: 12 Hard: 3
LC #104 Max Depth Binary Tree LC #226 Invert Binary Tree LC #100 Same Tree LC #102 Level Order Traversal LC #235 LCA BST LC #124 Binary Tree Max Path Sum LC #297 Serialize/Deserialize Tree LC #572 Subtree of Another Tree LC #543 Diameter Binary Tree
Dynamic Programming
Easy: 5 Med: 20 Hard: 10
LC #70 Climbing Stairs LC #198 House Robber LC #322 Coin Change LC #139 Word Break LC #300 Longest Increasing Subsequence LC #1143 LCS LC #0/1 Knapsack LC #416 Partition Equal Subset Sum LC #312 Burst Balloons LC #115 Distinct Subsequences
Graphs
Easy: 3 Med: 12 Hard: 3
LC #200 Number of Islands LC #207 Course Schedule LC #417 Pacific Atlantic Water LC #130 Surrounded Regions LC #994 Rotting Oranges LC #323 Connected Components LC #743 Network Delay Time (Dijkstra) LC #269 Alien Dictionary (topo sort)

The 15 Must-Master Patterns

Two Pointers
Sorted array problems. Reduce O(n²) to O(n). Left+right, fast+slow.
Sliding Window
Subarray/substring with constraint. Expand right, shrink left.
Binary Search
Any monotonic condition. O(log n). Search space reduction.
DFS Tree/Graph
Explore all paths. Recursion + backtrack. Path sum, islands.
BFS Shortest Path
Level-by-level. Queue. Shortest path in unweighted graph.
Heap / Top-K
Top-K elements. Min/max heap. O(n log k) vs O(n log n) sort.
Backtracking
Permutations, combinations, subsets. Choose → explore → unchoose.
Dynamic Programming
Optimal substructure + overlapping subproblems. Memo/tabulate.
Prefix Sum
Range sum queries in O(1). Build prefix array once, query fast.
Hash Map
O(1) lookup. Frequency count, anagram, two sum family problems.
Monotonic Stack
Next greater/smaller element. Temperature problem family.
Union Find
Disjoint sets. Connected components, cycle detection in graphs.
Trie
Prefix trees. Autocomplete, word search, dictionary problems.
Greedy
Local optimal → global optimal. Interval scheduling, activity selection.
Intervals
Merge, insert, overlapping intervals. Sort by start. Sweep line.
10

Backend Engineering Track

From legacy PHP to modern backend engineering — Laravel, APIs, queues, security, scaling.

PHP 5.6 → PHP 8.3 Migration Mindset

What to Unlearn (PHP 5.6 Habits)
  • Global functions for everything → use classes and DI
  • mysql_* functions → use PDO or Eloquent
  • register_globals → always explicit variable scope
  • No type hints → strict_types=1 everywhere
  • Mixed HTML in PHP files → separation of concerns
  • No error handling → try/catch, custom exceptions
  • include/require soup → PSR-4 autoloading
PHP 8.x Features to Master
  • declare(strict_types=1) — enable it in every file
  • Named arguments: fn(name: 'Alice', age: 25)
  • Match expressions vs switch — learn the difference
  • Null safe operator: $user?->profile?->avatar
  • Readonly properties + Constructor promotion
  • Enums — stop using string constants
  • Fibers — understand async PHP concepts
  • Union/Intersection types: int|string

Laravel Mastery Path

Level 1: Core
  • Service Container + Dependency Injection — understand, don't just use
  • Service Providers: how the framework boots
  • Facades: what they are (static proxy to container binding)
  • Middleware pipeline: request → middleware[] → controller → response
  • Eloquent: query builder, scopes, mutators, accessors, casts
  • Migrations: up/down, foreign keys, indexes in migration files
Level 2: Advanced
  • Events + Listeners + Observers — decoupled business logic
  • Jobs + Queues (Redis-backed) — async heavy operations
  • Scheduled tasks: Kernel.php scheduling
  • Notifications: email, Slack, database channels
  • Policies + Gates: authorization layer
  • Form Requests: validation + authorization in one class
  • API Resources: transform Eloquent models to JSON consistently
Level 3: Expert
  • Custom Artisan commands for ops tasks
  • Livewire or Inertia.js for server-driven UI
  • Octane (Swoole/RoadRunner) — 10x performance PHP
  • Horizon dashboard for queue monitoring
  • Telescope for debugging + request inspection
  • Package development: create your own Laravel package
  • Multi-tenancy: Spatie Multi-Tenancy or custom implementation
Best Laravel Learning Path
1. Official Laravel docs (laravel.com/docs) — read end to end, not just what you need
2. Laracasts (free + paid) — Jeffrey Way's videos are industry standard
3. Laravel Daily (YouTube, free) — real-world patterns and code reviews
4. "Laravel Up & Running" book by Matt Stauffer — read cover to cover

API Engineering — Build APIs like a Backend Architect

  • RESTful design principles: Resource naming (nouns not verbs), HTTP verbs correctly used, status codes (200, 201, 400, 401, 403, 404, 422, 500)
  • API versioning: URI versioning (/api/v1/) vs header versioning — understand tradeoffs
  • Authentication: JWT tokens (how they work, not just laravel-jwt), OAuth2 flow (authorization code, client credentials), API keys for server-to-server
  • Rate limiting: Laravel's ThrottleRequests middleware, Redis-backed rate limiting, per-user vs per-IP
  • Pagination: Cursor-based (for large datasets) vs offset-based — know when to use each
  • API documentation: OpenAPI/Swagger spec, L5-Swagger package, Postman collections
  • GraphQL basics: Understand the paradigm, when REST is better vs when GraphQL wins
  • Webhook design: Outgoing webhooks with signature verification (HMAC-SHA256)

Architecture Patterns You Must Know

Repository Pattern
Decouple data access from business logic. Swap MySQL for Elasticsearch tomorrow without changing business code. Use in Laravel with interfaces.
Service Layer
Business logic lives in Service classes, not controllers. Controllers are thin orchestrators. Services are fat with logic.
Action Classes
Single-responsibility classes for specific operations. CreateUserAction, ChargeSubscriptionAction. Popular in Laravel community.
Event-Driven Design
UserRegistered event → SendWelcomeEmailListener + CreateDefaultSettingsListener. Decoupled, testable, scalable.
CQRS (basic)
Separate read models from write models. Read from optimized query, write through command. Scales reads and writes independently.
DDD Concepts
Bounded contexts, aggregates, value objects, domain events. Don't go full DDD day 1 — understand the vocabulary and apply gradually.

Security — OWASP Top 10 for PHP Developers

VulnerabilityWhat It IsHow to Prevent
SQL InjectionMalicious SQL in user inputPrepared statements, Eloquent ORM, never concatenate SQL
XSSScript injection in outputBlade's {{ }} auto-escapes, never use {!! !!} with user data
CSRFForged requests from other sitesLaravel's CSRF middleware, @csrf in all forms
Broken AuthWeak session/token managementLaravel Sanctum, bcrypt passwords, secure cookie flags
IDORAccessing other users' resourcesPolicy-based authorization, never expose sequential IDs (use UUIDs)
Mass AssignmentUpdating unintended fieldsFillable/guarded in Eloquent models — never use $fillable = ['*']
Sensitive DataExposing passwords, tokensNever log sensitive data, encrypt at rest, use .env for secrets
11

Frontend Engineering Track

JavaScript mastery → TypeScript → React — the path to a complete full-stack engineer.

Stage 1: JavaScript Fundamentals (4 weeks)
Master the Language First, Then the Framework
  • The Event Loop — watch "What the heck is the event loop anyway?" by Philip Roberts (JSConf EU). Watch 3 times until you can explain it to someone.
  • Closures + Scope — write 20 functions demonstrating closure behavior. Test in browser console.
  • Prototype chain — understand why Object.create() and class syntax are the same thing.
  • Promises + async/await — build a fake API that chains 3 async operations: fetch user → fetch posts → fetch comments. Handle errors properly.
  • ES6+ features — destructuring, spread, rest, optional chaining, nullish coalescing, template literals.
  • Module system — CommonJS vs ES Modules — why they differ and when each is used.
  • Book: "You Don't Know JS" (free on GitHub) — read all 6 volumes over 6 months
Stage 2: TypeScript (3 weeks)
Type Safety Changes How You Think
  • Start with tsconfig basics — strict mode from day 1
  • Types vs Interfaces — when to use each
  • Generics — write your own generic utility functions (like a typed fetch wrapper)
  • Union types, discriminated unions — model your domain with types
  • Utility types: Partial, Required, Pick, Omit, Record — use all of them
  • Type guards + type narrowing — instanceof, typeof, user-defined type guards
  • Resource: TypeScript official handbook (free) + Matt Pocock's Total TypeScript (some free)
Stage 3: React (6 weeks)
Component Architecture + Modern React Patterns
  • Hooks deep dive — useState, useEffect, useContext, useReducer, useCallback, useMemo, useRef — write examples for every single one
  • Custom hooks — extract reusable logic. useFetch(), useLocalStorage(), useDebounce()
  • State management — Context API (for simple global state) → Zustand (for medium apps) → Redux Toolkit (for complex apps). Learn in this order.
  • React Query / TanStack Query — for server state management. This is how production apps handle API state.
  • Performance — React.memo, useMemo, useCallback — understand when to use them (hint: not everywhere)
  • Patterns — compound components, render props, HOCs — read the docs, not just tutorials
  • Testing — React Testing Library + Vitest. Test behavior, not implementation.
12

Database Engineering Track

SQL mastery, performance tuning, NoSQL patterns, Redis caching strategies.

SQL Mastery Path
  • Joins: Master all join types with visual diagrams. Write each one 10+ times.
  • Window functions: ROW_NUMBER, RANK, LAG, LEAD, SUM OVER — these replace many subqueries
  • CTEs: WITH clause for readable, reusable subqueries
  • Recursive CTEs: For hierarchical data (categories, org charts)
  • Stored procedures: Understand, but prefer application-level logic in modern apps
  • Triggers: Use sparingly — can create debugging nightmares
  • Practice: SQLZoo.net, pgexercises.com, HackerRank SQL
Indexing & Query Optimization
  • EXPLAIN + EXPLAIN ANALYZE — run this on every slow query. Read it like a detective.
  • B-Tree indexes — how they work, why they help range queries
  • Composite indexes — column order matters. Leading column rule.
  • Covering indexes — index that covers all columns in SELECT (no table read)
  • Index cardinality — high cardinality = better index candidate
  • N+1 problem — recognize it, prevent it with eager loading
  • Slow query log — enable it, read it weekly on production
Redis Mastery
  • Data types: Strings, Lists, Sets, Sorted Sets, Hashes — know when each applies
  • Caching patterns: Cache-aside, Write-through, Write-behind
  • TTL strategy — short TTL for volatile data, long for static
  • Redis Pub/Sub for simple messaging
  • Rate limiting with Redis: INCR + EXPIRE pattern
  • Session storage in Redis (Laravel: CACHE_DRIVER=redis)
  • Laravel Horizon: monitor Redis queues visually
CouchDB → Modern NoSQL Understanding
  • Document databases: when schema-less is actually an advantage
  • CouchDB's MVCC — Multi-Version Concurrency Control vs MySQL locking
  • MapReduce views in CouchDB — understand, then move to better options
  • CAP theorem: Consistency vs Availability vs Partition tolerance
  • MongoDB: when it beats CouchDB for modern applications
  • Understand: SQL for transactions, NoSQL for flexibility/scale. Both have place.
13

System Design Roadmap

How to design systems that handle millions of users — the skill that separates senior from junior.

System design is not about memorizing architectures. It's about understanding tradeoffs. Every architectural decision has a cost. Your job is to know the cost and justify your choice.

Core Concepts (Learn In This Order)

ConceptWhat to UnderstandWhen It Matters
Vertical ScalingBigger server. Simple but has ceiling. SQL DB bottleneck.Early stage, low traffic
Horizontal ScalingMore servers. Needs load balancer, stateless design.10k+ concurrent users
Load BalancerNginx/HAProxy/AWS ALB. Round-robin vs least-connections vs IP-hash.Multiple app servers
CDNCloudflare/AWS CloudFront. Static assets globally cached. Edge locations.Static files, global users
Database ReplicationPrimary (writes) + Read replicas (reads). Eventual consistency tradeoff.Read-heavy applications
Database ShardingPartition data across multiple DBs. Horizontal vs range sharding.100M+ records, write-heavy
Caching LayersRedis/Memcached. Reduce DB hits. Cache invalidation strategies.Repeated expensive queries
Message QueuesRabbitMQ/Kafka. Decouple services. Async processing. Backpressure.Background jobs, microservices
API GatewaySingle entry point. Auth, rate limit, routing to microservices.Multiple backend services
MicroservicesIndependent deployable services. Owns its data. Complex but scalable.Large teams, independent scaling

Must-Study System Design Problems

Design URL Shortener
Hash generation (Base62), collision handling, analytics, redirect performance. This is the "hello world" of system design.
Design a Chat System
WebSockets, message storage, read receipts, online presence. Real-time = long-polling vs WebSocket vs SSE decision.
Design Instagram/Twitter Feed
Fan-out on write vs read. Timeline cache. Celebrity problem. Sharding by user_id.
Design a Rate Limiter
Token bucket, sliding window, fixed window algorithms. Redis implementation. Distributed rate limiting.
Design an ERP Inventory
Transactional consistency, concurrent stock updates, audit log, warehouse multi-location, FIFO/LIFO costing.
Design a Notification System
Multi-channel (email, SMS, push, in-app). Queue-backed. Template engine. Delivery status tracking.
Essential Resources for System Design
1. "Designing Data-Intensive Applications" by Martin Kleppmann — the bible of distributed systems
2. SystemDesignPrimer on GitHub (donnemartin/system-design-primer) — 250k+ stars, comprehensive free resource
3. ByteByteGo Newsletter by Alex Xu (free tier) — visual explanations of real systems
4. "System Design Interview" book by Alex Xu — Vol 1 and Vol 2
14

ERP Business Knowledge

Understand the business domain you're building for — this makes you 10x more effective than a pure technologist.

📦 Inventory Management
  • Items/SKUs, variants, units of measure, categories
  • Stock movements: GRN (Goods Receipt Note), stock adjustment, transfer
  • Costing methods: FIFO, LIFO, Weighted Average — affects P&L
  • Reorder points, minimum stock alerts
  • Warehouse management: bin/shelf locations, barcode integration
  • Batch/lot tracking for pharma/food industries
🛒 Purchase Management
  • Vendor master: contact, payment terms, credit limit
  • Purchase requisition → Purchase Order → GRN → Bill → Payment
  • 3-way matching: PO + GRN + Bill must match before payment
  • Vendor pricing: item-specific pricing, discounts, tax templates
  • Purchase returns: debit note process
  • Multi-currency purchases: exchange rate management
💼 Sales Management
  • Customer master: credit limit, payment terms, sales rep
  • Quotation → Sales Order → Delivery Note → Invoice → Payment
  • Pricing rules: customer-specific, volume discounts, promotional pricing
  • Sales returns: credit note process
  • Territory management, sales team commissions
  • Partial delivery, backorder management
👥 HR & Payroll
  • Employee master: departments, designation, joining date, documents
  • Leave management: types, entitlements, approval workflow
  • Attendance: manual + biometric integration concepts
  • Payroll: salary structures, earnings, deductions, net pay
  • Statutory: PF, ESI, TDS, professional tax (India) / equivalent for other regions
  • Payslip generation, bulk salary processing
📊 Reports & Dashboards
  • Operational reports: stock ledger, purchase register, sales register
  • Financial reports: P&L, Balance Sheet, Cash Flow
  • KPI dashboards: revenue trend, inventory turnover, DSO
  • Drill-down navigation: summary → detail → source document
  • Export: Excel, PDF, CSV — always support all three
  • Scheduled reports: email delivery, automated generation
✅ Workflow & Approvals
  • Configurable approval workflows: role-based, amount-based
  • Sequential vs parallel approval: understand the difference
  • Email + in-app notifications on approval actions
  • Audit trail: who approved what, when, with what comment
  • Delegation: approve on behalf when approver is on leave
  • SLA monitoring: flag overdue approvals automatically

ERP System Architecture

Multi-Tenant Design
  • Separate DBs per tenant — most secure, highest cost (Spatie multi-tenancy package)
  • Shared DB, tenant_id column — cheapest, must enforce in every query
  • Hybrid — shared DB for small, dedicated for large tenants
  • Always: global middleware that sets tenant context on every request
  • Tenant isolation: one tenant must never see another's data — test this explicitly
GST / Tax Engine Design
  • Tax templates: IGST (18%), CGST (9%) + SGST (9%) — India model
  • Apply tax at line item level, not document level
  • Tax exclusive vs inclusive — affects price display and calculation
  • HSN/SAC codes mapped to items for GST returns
  • GSTR-1, GSTR-3B report generation from sales transactions
  • Input Tax Credit (ITC) tracking from purchase transactions
Study ERPNext (Open Source) Source Code
ERPNext (github.com/frappe/erpnext) is the world's best open-source ERP. Read its source code — specifically the accounts, stock, and HR modules. This will teach you more about ERP architecture than any course. It's built in Python/Frappe but the business logic is universal.

Accounting Basics Every ERP Developer Must Know

The Double-Entry System

Every transaction has two sides: Debit and Credit. They must always be equal.

  • Assets (Debit increases) — Cash, AR, Inventory, Fixed Assets
  • Liabilities (Credit increases) — AP, Loans, Tax Payable
  • Equity (Credit increases) — Capital, Retained Earnings
  • Revenue (Credit increases) — Sales, Interest Income
  • Expenses (Debit increases) — COGS, Salaries, Rent
  • Example: Sale of ₹10,000: DR Accounts Receivable ₹10,000 / CR Sales Revenue ₹10,000
Financial Statements a Dev Must Understand
  • P&L (Income Statement): Revenue - Expenses = Net Profit. Covers a period.
  • Balance Sheet: Assets = Liabilities + Equity. Point in time snapshot.
  • Cash Flow Statement: Operating + Investing + Financing activities. Cash is king.
  • Trial Balance: All accounts listed with DR/CR balances. Should balance.
  • Chart of Accounts: Hierarchical list of all accounts in the system. Design this carefully.
15

DevOps & Deployment Track

From "it works on my machine" to production-grade deployment with CI/CD pipelines.

Linux + Server Basics
  • File system navigation, permissions (chmod, chown, sudo)
  • Process management: ps, top, htop, kill, systemctl
  • Network: netstat, ss, curl, wget, ping, nmap basics
  • Text tools: grep, awk, sed, tail -f for log analysis
  • SSH: key-based auth, ssh-agent, port forwarding
  • Cron jobs: syntax, editing, testing
  • Practice: Linux Survival (free), OverTheWire Bandit wargame
Nginx Configuration
  • Server blocks (virtual hosts) — serve multiple apps on one server
  • Reverse proxy to PHP-FPM: upstream fastcgi configuration
  • SSL/TLS: Let's Encrypt with Certbot — always HTTPS
  • Gzip compression — reduce bandwidth by 70%
  • Rate limiting with nginx: limit_req_zone
  • Static file caching: cache-control headers for assets
  • Security headers: X-Frame-Options, Content-Security-Policy
Docker (Essential)
  • Understand: images vs containers vs registries
  • Write Dockerfiles for PHP-FPM + Nginx + MySQL services
  • Docker Compose: multi-service local development environment
  • Docker networks: how services communicate by name
  • Volumes: persistent data for databases
  • Multi-stage builds: slim production images
  • Push to Docker Hub or GitHub Container Registry
CI/CD Pipeline
  • GitHub Actions: workflow files, triggers, jobs, steps
  • Pipeline stages: test → build → lint → deploy
  • Secrets management: GitHub Secrets, never hardcode credentials
  • Auto-deploy to Railway/Render on push to main branch
  • PHP specific: run PHPStan, PHPUnit, PHP-CS-Fixer in pipeline
  • Slack/Discord notifications on deploy success or failure
Git Mastery
  • Branching strategies: Gitflow vs trunk-based development
  • Interactive rebase: squash, edit, reorder commits
  • git bisect: binary search for the commit that introduced a bug
  • git stash, git cherry-pick, git reflog — advanced recovery
  • Conventional commits: feat/fix/docs/chore/refactor prefix
  • PR review etiquette: small PRs, clear descriptions, self-review first
  • git hooks: pre-commit lint, pre-push test run
Monitoring & Observability
  • Application monitoring: Sentry (error tracking, free tier)
  • Log aggregation: Papertrail or Logtail (free tier)
  • Uptime monitoring: UptimeRobot (free, checks every 5 min)
  • Performance: Laravel Debugbar (dev), Telescope (dev/staging)
  • Server metrics: Netdata or Grafana + Prometheus (self-hosted)
  • Alert on: 5xx errors, slow queries (>1s), server CPU >80%
16

Project Roadmap

Build in public. Every project is a portfolio piece, a learning milestone, and a confidence builder.

Beginner Projects (Months 1-2)

🟢 Beginner
CLI Task Manager
A command-line to-do app in pure PHP. No framework. Shows you can code without scaffolding. Add/list/delete/complete tasks. Persist to JSON file.
Pure PHP 8CLIJSONOOP
🟢 Beginner
Vanilla JS Quiz App
Multi-step quiz with timer, score tracking, and results page. No frameworks. Proves you understand DOM, events, async, and state management without React.
Vanilla JSHTML/CSSLocalStorage
🟢 Beginner
SQL Analytics Dashboard
A static PHP page querying a MySQL database with complex SQL — JOINs, GROUP BY, window functions. Shows SQL mastery without hiding behind ORM.
PHPMySQLPDORaw SQL

Intermediate Projects (Months 3-5)

🟡 Intermediate
Project Management API
Full REST API with teams, projects, tasks, comments, file attachments. JWT auth, role-based access (Admin/Member), email notifications via queues. Full test coverage.
Laravel 11MySQLRedisLaravel QueuesPHPUnit
🟡 Intermediate
React SaaS Dashboard
Frontend for the Project Management API. Charts (Recharts), data tables, Kanban board, team management UI. TypeScript + React Query for all data fetching.
ReactTypeScriptReact QueryTailwindRecharts
🟡 Intermediate
Inventory Management Module
Full inventory system: products, categories, suppliers, stock movements (in/out/transfer), stock valuation (FIFO), low stock alerts via email, dashboard.
LaravelLivewireMySQLRedisPDF Export

Advanced Production Projects (Months 6-12)

🔴 Advanced
Full-Stack ERP System
Multi-tenant ERP with: Inventory, Purchase, Sales, Accounts Receivable/Payable, HR, Payroll, and GST reports. Approval workflows, role-based permissions, real-time notifications, and a white-label dashboard.
LaravelReact+TSRedisMySQLMulti-tenantDockerGitHub CI/CD
🔴 Advanced
SaaS Subscription Platform
Billing system with Stripe integration, plan management, usage-based billing, metered features, customer portal, dunning management, and churn analytics.
Laravel CashierStripeReactRedisWebhooks
🔴 Advanced
Real-Time Collaboration Tool
Document editor with live cursors, comments, version history, WebSocket presence indicators. Laravel Reverb (native WebSockets) + React frontend.
Laravel ReverbWebSocketsReactOperational Transform
17

Exact Resources List

Free first. Paid only if genuinely worth it. No filler.

Books — Ranked by Priority

#BookTopicCostWhen to Read
1Clean Code — Robert MartinCode QualityFree PDFMonth 1
2You Don't Know JS — Kyle SimpsonJavaScriptFree (GitHub)Month 2-3
3Cracking the Coding Interview — Gayle McDowellDSA + InterviewsPaid (~$35)Month 3 onwards
4Laravel Up & Running — Matt StaufferLaravelPaid (~$49)Month 2-4
5Designing Data-Intensive Applications — Martin KleppmannSystem DesignPaid (~$50)Month 5 onwards
6The Pragmatic Programmer — Hunt & ThomasEngineering MindsetPaid (~$40)Month 2
7System Design Interview Vol 1 & 2 — Alex XuSystem DesignPaid (~$30 each)Month 8 onwards
8PHP: The Right Way — phptherightway.comPHPFreeMonth 1
9JavaScript Info — javascript.infoJavaScriptFreeMonth 2
10Database Internals — Alex PetrovDB Deep DivePaidMonth 9 onwards

YouTube Channels — Only the Best

NeetCode
DSA problems explained with patterns. Best channel for LeetCode. 250+ videos, all free. Watch EVERY single video.
Fireship
100-second concept intros + deeper dives. Best for staying current on tech trends. Modern JS/TS/web content.
Laracasts
Jeffrey Way's PHP/Laravel channel. Some free content, paid subscription for full access. Industry gold standard.
ByteByteGo
Alex Xu's system design channel. Visual explanations of how large-scale systems work. Essential for interviews.
Traversy Media
Brad Traversy's project-based tutorials. React, PHP, full-stack projects. Good for following along to solidify concepts.
Hussein Nasser
Deep backend engineering content. Postgres internals, WebSockets, HTTP/2, TLS. Makes you think like a backend architect.
The Primeagen
Raw engineering content. Algorithms, Neovim, code quality, engineering culture. Challenging but rewarding.
Laravel Daily
Povilas Korop's real-world Laravel patterns. Short, practical, opinionated. Watch for code review content.

Courses — Free First, Paid If Worth It

CoursePlatformTopicCost
CS50x — HarvardedX (free audit)Computer Science FundamentalsFree
The Odin Projecttheodinproject.comFull-Stack Web DevFree
React — Official Docs Tutorialreact.devReact FundamentalsFree
TypeScript Handbooktypescriptlang.orgTypeScriptFree
Laravel Bootcamplaravel.com/bootcampLaravel + InertiaFree
Laracasts Full Laravellaracasts.comLaravel Complete$99/yr
System Design Fundamentalseducative.io/grokkingSystem Design$59/mo
Zero to Mastery DSAudemy.comDSA~$15 sale
18

AI Usage Rules

Use AI like a senior engineer — as a powerful tool, not a crutch.

❌ NEVER Use AI For
  • Writing code for DSA problems — this kills your growth 100%
  • Debugging before you've spent 30 minutes trying yourself
  • Writing boilerplate code you haven't written manually at least once
  • Understanding concepts — AI summaries are shallow; read documentation
  • Writing tests — learn to write tests yourself first
  • Your first implementation of any new pattern
✅ USE AI For
  • Reviewing code you've already written — "review this for issues"
  • Explaining error messages after you've researched them
  • Generating test data / seed data / boilerplate config files
  • Second opinion on architecture after you've made a decision
  • Documentation writing after you understand the code
  • Translating concepts between languages (PHP → TypeScript equivalent)

The 25-Minute Rule

Before Asking AI Anything
  • Step 1 (5 min): Read the error message completely. Google the exact error string.
  • Step 2 (10 min): Read the official documentation for the function/method involved.
  • Step 3 (5 min): Add console.log / var_dump at every step. Print the actual values.
  • Step 4 (5 min): Write down your hypothesis: "I think the problem is X because Y."
  • If still stuck: Now you can ask AI — and your question will be 10x better because you know the context.
  • The 25-minute investment also means you often solve it yourself, which builds memory far stronger than AI answers.
19

Debugging Mastery

The single skill that separates "can code" from "can engineer". Debug like a detective.

The Scientific Debugging Method

Step 1
Reproduce Reliably
If you can't reproduce the bug consistently, you can't fix it. Find the exact steps, data, and conditions that trigger it every time. Write them down.
Step 2
Read the Error Completely
The full stack trace, not just the last line. The error usually tells you exactly what's wrong — most developers don't read past the first line. Read every line.
Step 3
Form a Hypothesis
Don't randomly change code. State: "I believe the bug is in [location] because [reason]." Write it down. This forces clear thinking.
Step 4
Isolate the Problem
Binary search the codebase. Is the bug in the frontend or backend? Is it in the database or application layer? Is it in function A or function B? Cut the problem in half each time.
Step 5
Print → Test → Analyze
Add logging at every step of your hypothesis path. Check actual vs expected values. In PHP: dd(), Log::debug(). In JS: console.log() with labels.
Step 6
Fix + Test + Understand
Fix only the minimum change needed. Then test not just the fixed case but adjacent cases. Most importantly: understand WHY the bug existed. This prevents future bugs.
PHP Debugging Tools
  • dd($variable) — dump and die in Laravel
  • Log::debug('label', ['data' => $data])
  • Xdebug + VS Code — step debugger, breakpoints, variable watch
  • Laravel Telescope — request/response inspector, query log
  • Laravel Debugbar — in-browser query and timing panel
  • PHP error_log() for production debugging
JavaScript Debugging Tools
  • Chrome DevTools: breakpoints, call stack, watch expressions
  • console.table(array) for array inspection
  • console.trace() to see call stack at any point
  • Network tab: inspect API requests/responses exactly
  • React DevTools: component state, props inspector
  • Redux DevTools: time-travel debugging for state
20

Interview Preparation

A systematic approach to FAANG-level technical interviews — starting month 8.

⚠️ Don't Start Interview Prep Too Early
Start interview prep at month 8-9, not month 1. Skills first, interview polish later. Many engineers prep interviews before having skills — they get lucky once and plateau. Build real skills first.
Phase 1: DSA Interview Prep (Weeks 1-6)
  • Complete NeetCode 150 — all patterns at medium difficulty
  • Timed sessions: 35 minutes per problem, no hints
  • Talk through your thinking out loud — practice this alone
  • After solving: analyze time/space complexity out loud
  • Re-solve problems from 2 weeks ago — retention check
  • Target: 200+ solved, 70% acceptance rate on medium
Phase 2: System Design (Weeks 4-8)
  • Design 1 system per week: URL shortener, Uber, WhatsApp, Netflix
  • Use the framework: Requirements → Estimation → API design → HLD → LLD → Bottlenecks
  • Draw diagrams on paper — practice whiteboard speed
  • Watch ByteByteGo for each system, then design it yourself without looking
  • Record yourself explaining — painful but extremely effective
Phase 3: Behavioral (Weeks 5-8)
  • STAR method: Situation, Task, Action, Result — for every story
  • Prepare 8 situations from your work — difficult bug, conflict, leadership, failure
  • Write each story down, time it (2-3 minutes max per answer)
  • Research the company: product, tech stack, engineering blog, values
  • Questions to ask them: engineering culture, tech debt policy, growth path
Mock Interviews (Weeks 6-8)
  • 3 mock interviews per week on Pramp.com (free) or Interviewing.io
  • Review each session recording — painful, necessary
  • Ask trusted developer friends for mock sessions
  • Record yourself solving LeetCode — watch the playback
  • Target companies: prepare company-specific questions from Glassdoor + Leetcode discuss
21

Portfolio & Career Strategy

Build a portfolio that gets you interviews, not just compliments.

GitHub Profile (Month 2 Onwards)

  • Profile README: Short bio, tech stack, current focus, links. Keep it simple and professional.
  • Green contribution graph: Commit something every day, even if it's 1 line or a documentation fix.
  • Pinned repos: Pin your 6 best projects — not all of them. Quality over quantity.
  • README quality: Every project needs: description, live demo link, tech stack, setup instructions, screenshots. This is your first impression.
  • Commit messages: Conventional commits format. Tells a story of professional engineering.
  • Open source contributions: Even 1 PR to a popular Laravel package adds credibility.

Technical Blog (Month 4 Onwards)

  • Write on dev.to (free, good SEO) or Medium (larger audience)
  • Topics: things you just learned, bugs you fixed, tutorials for what you built
  • One post per month minimum — quality matters more than frequency
  • Share on LinkedIn, Twitter/X — builds personal brand over time
  • Repurpose into YouTube shorts or Twitter threads for more reach

Resume Strategy

Resume Rules (Non-Negotiable)
  • 1 page maximum until 7+ years experience
  • Every bullet: Action verb + Metric + Result. "Reduced query time by 60% by adding composite index" not "Optimized database"
  • Show GitHub link, LinkedIn, deployed project links — make it clickable in PDF
  • Skills section: honest. Don't list "React" if you've only done 1 tutorial.
  • ATS-friendly: Use standard section headers, no tables/columns, .docx format for ATS, PDF for humans
  • Tailor for each application: mirror the job description keywords

Remote Job Readiness

  • LinkedIn: Complete profile, "Open to Work" (private), connect with 20 engineers/recruiters per week
  • Job boards: Remotive.com, Remote.co, We Work Remotely, Toptal (for top 3%), Turing.com
  • English communication: Write emails in English daily, join English-speaking dev communities on Discord, watch English tech content without subtitles
  • Time zone strategy: IST overlaps well with EU mornings and US evenings — leverage this
  • Rate: Research Glassdoor + Levels.fyi for market rates. Don't undervalue PHP/Laravel skills.
22

Mistakes to Avoid

The exact pitfalls that slow down 90% of self-improving developers.

Tutorial Hell
Watching 5 React tutorials without building anything. Tutorials feel like learning but the knowledge evaporates in 48 hours. For every 1 hour of tutorial, build for 2 hours.
Random LeetCode Grinding
Solving 300 random problems is worse than solving 150 in a specific order by pattern. Use NeetCode 150, not random daily challenges as your main practice.
Framework Before Language
Learning React before JavaScript, or Laravel before PHP. When something breaks, you have no foundation to debug. Language first. Always.
Shiny Object Syndrome
Switching from Laravel to Django to Rails every month. Pick one backend stack and go deep. Depth beats breadth for the first 3 years. PHP/Laravel is a great choice.
Not Writing Tests
Professional engineers write tests. Starting projects without tests creates technical debt that kills velocity. Write at least feature tests for every API endpoint from month 3.
Waiting for Perfection
Spending 2 weeks "planning" a project instead of starting. Start with the simplest possible version that proves the core idea. Ship, learn, iterate.
Not Reading Error Messages
Copying the error title into Google without reading the full message first. Stack traces tell you the exact line, file, and call chain. Read them completely.
Skipping Version Control Hygiene
"updated stuff" commit messages. Pushing directly to main. No .gitignore. These habits mark you as junior. Discipline in version control signals professionalism.
Learning Without Building
Reading Clean Code without applying it to a real project. Reading about Redis without setting it up. Every concept must be applied within 48 hours or it evaporates.
23

Final Action Checklist

Start today. Not Monday. Not next month. Today.

Do These TODAY

  • Install Obsidian and create your engineering knowledge base
  • Create a LeetCode account and solve 1 easy array problem without AI
  • Read phptherightway.com — first 3 chapters
  • Set up a local PHP 8.3 development environment (Laravel Herd on Mac, or manual on Linux)
  • Create a private GitHub repo: "daily-code-journal" — commit your first note
  • Block social media from 6am-9am and 6pm-9pm using Cold Turkey or Freedom app
  • Write down your 12-month goal in specific terms: "By [date], I will [specific role] at [type of company] earning [salary]"

Do These This Week

  • Solve 5 LeetCode easy problems — Arrays topic — without AI
  • Write a PHP class from scratch: a BankAccount with deposit/withdraw/balance methods
  • Install MySQL locally and create a database for a library system — 5 tables, proper foreign keys
  • Watch NeetCode's Arrays and Hashing playlist (8 videos)
  • Read Clean Code chapters 1-3 and apply 1 principle to existing code you've written
  • Set up Xdebug in your local environment and step through 1 existing function

Do These This Month

  • Complete 30 LeetCode easy problems across arrays, strings, hashmaps
  • Build the CLI Task Manager project in pure PHP
  • Read PHP The Right Way completely
  • Design and build an e-commerce database schema with proper normalization
  • Build a raw PHP REST API (no framework) with 5 endpoints
  • Deploy something — anything — to a live server (Railway.app free tier)
  • Publish your first technical note or blog post
  • Spend 0 hours asking AI to write code for you during learning sessions

Track Your Progress

Weekly Review Questions
  • How many problems did I solve without AI this week?
  • What new concept did I deeply understand (not just use)?
  • What did I build that I couldn't build last week?
  • What mistake did I make, and what did it teach me?
  • Am I spending more time building or more time watching tutorials?
  • Did I commit code every day this week?
🏁 The Final Word From Your Mentor
You are not starting from zero. You have 3 years of real-world context — that's a foundation most CS graduates don't have. What you need is structured, disciplined, fundamentals-first rebuilding. The developers who make it aren't smarter than you. They're more consistent. They show up every day. They struggle through the hard problems instead of asking AI. They write the same function 10 times until it's in their muscle memory. You already know what to do. The question is whether you'll do it daily, without excuses, for 365 days. If yes: a year from now, you'll look back at this roadmap and realize you've exceeded it.