Part I: Strategy & All 4 Rounds Overview

1.1

Toptal Overview

Toptal is the world's largest network of top freelance talent across design, software, finance, and project management. It's not just another freelance platform—it's an elite membership where only the top 3% of applicants are accepted.

Why Toptal Matters

Toptal is fundamentally different from other freelance platforms. Toptal vets every single candidate through a rigorous 4-round process. The result? Premium clients paying top dollar for vetted, senior-level talent. According to Toptal's own data, members earn 2-3x more than comparable platforms because clients trust the quality.

✓ Top 3% Network: If you pass all 4 rounds, you join an exclusive group of 15,000+ professionals out of over 500,000+ applicants annually. That's genuine scarcity and market value.

The Three Top Reasons to Target Toptal

1. Premium Hourly Rates

Toptal clients pay 40-70% more than typical freelance rates because they're vetted, mid-market companies and enterprises. C# developers on Toptal average $85-150/hour (USD), while freelance platforms see $40-70.

Why? When Toptal says "top 3%", clients believe it and pay accordingly.

2. Quality of Work

Toptal's vetting means you're competing only with high-caliber developers. No race-to-the-bottom pricing. No managing inexperienced freelancers. You work on architecture, mentoring, and complex problems.

Why? The 4-round screening filters out 97% of applicants.

3. Consistency & Stability

Toptal's matching algorithm connects you with long-term projects (3-12 months common). Most members report 70-85% engagement rates, meaning steady income, not feast-famine.

Why? Toptal invests in matching quality and client retention.

4. Network Effects

Being part of the top 3% opens doors to partnerships, referrals, and a reputation that compounds over time. Toptal alumni are sought after.

Why? The brand is real, and the network is valuable.

ℹ Reality Check: Toptal is hard to pass. But if you do, the ROI is massive. One 3-month engagement at $100/hour (120 hours/month) = $36,000. Can you spend 80 hours studying to make that much? Absolutely.

1.2

The 4 Rounds Explained

Toptal's vetting process has four distinct stages. Each round tests different skills and filters out roughly 70-90% of candidates. Here's what you're up against.

Round	Format	Duration	Pass Rate	What It Tests
Round 1: Communication	Video Interview (1-on-1 with Toptal screener)	15–30 min	26.4%	English fluency (B2+ minimum, C1 preferred), motivation, relevant experience, hourly rate fit
Round 2: Codility Test	Auto-graded coding problems (Codility platform)	90 min	7.4%	Algorithmic thinking, data structure knowledge, performance optimization, edge case handling
Round 3: Live Coding	Screen-shared pair programming (Toptal engineer + you)	40 min	3.6%	Problem-solving under pressure, communication, code clarity, REACTO methodology
Round 4: Take-Home Project	Real-world system design & implementation (2 weeks to complete)	2 weeks (flex)	3.2%	Clean architecture, code quality, documentation, time management, junior developer mentoring

! The Funnel Effect: Out of 1,000 applicants: 264 pass Round 1 → 20 pass Round 2 → 1 passes Round 3 → 1 might pass Round 4. That's 0.1% final acceptance. This is intentional. Toptal sells "top 3%", but they mean of total talent pool (now ~500K+), not interview funnel.

Round 1: Communication Interview (26.4% Pass)

This is your first gate. A Toptal screener interviews you for 15–30 minutes via video. They assess:

English Fluency: B2 level minimum (upper-intermediate). Can you understand accented questions fast? Can you think and respond smoothly?
Motivation: Why Toptal? Why now? Are you serious or just testing?
Relevant Experience: Years in C#/.NET? Have you shipped production code?
Hourly Rate: Are you in the right range for the market? Too low = red flag (why?), too high = unlikely to match.
Availability: Full-time? Part-time? Flexible?

⚠ Common Round 1 Mistakes: Rambling answers, poor audio/lighting, being vague about experience, not asking questions, seeming unmotivated. Toptal wants professionals, not gamblers.

Round 2: Codility Test (7.4% Pass)

You solve 3 algorithmic problems in 90 minutes on the Codility platform. The platform auto-grades based on:

Correctness: Does your solution produce correct output for all test cases?
Performance: Does it complete within time/memory limits?
Score: Toptal's passing threshold is roughly 70/100 overall (roughly 100 Easy + 100 Medium + 10 Hard points out of 300 available).

✓ Typical Round 2 Problems: Array manipulation (sorting, searching), hash map usage, tree/graph basics, string manipulation, dynamic programming (1 medium problem). NOT complex system design. NOT distributed systems. Focused on fundamentals at scale.

Round 3: Live Coding (3.6% Pass)

A Toptal engineer sits with you (screen-shared) and you solve 2 problems in 40 minutes. This is LIVE, meaning:

You can't hide: They see your thinking, debugging, and communication in real-time.
You must think aloud: Explain your approach before coding. Use REACTO (see Golden Rules).
Edge cases matter: They'll ask, "What if the input is empty?" or "What about negatives?" Multiple times.
Time pressure: 40 minutes for 2 problems. ~20 min per problem. If you spend 10 min on approach, you have 10 min to code and test.

! Round 3 is the "Soft Skills" Gate: You can be smart, but if you panic, can't explain, or get defensive about feedback, you fail. Communication is 50% of the score.

Round 4: Take-Home Project (3.2% Pass)

You get a spec and 2 weeks to build something real. Requirements typically include:

Feature Set: Small e-commerce, blog, task app, etc. Typically C# backend + optional frontend.
Clean Code: SOLID principles, testable, well-structured.
Documentation: README, setup instructions, architecture diagram.
Code Review Readiness: They'll review line-by-line. Any "WTF?" moments = problem.

✓ Round 4 Strategy: Don't over-engineer. Deliver a simple, clean solution that demonstrates: dependency injection, repository pattern, unit tests, error handling. Junior devs should be able to read and extend it. This is what Toptal clients value.

1.3

Why 92.6% Fail Round 2

Round 2 has the steepest drop-off because candidates prepare the wrong way. Here are the five most common failure patterns.

Mistake 1: Studying Random LeetCode Instead of Codility Lessons

LeetCode and Codility have different problem distributions. LeetCode is broad; Codility is specific.

❌ Wrong: Random LeetCode

Solve 200 random problems across 50 categories

No structured learning path

Miss critical Codility patterns (caterpillar, prefix sums)

Study time wasted on advanced problems you won't see

✓ Right: Codility Lessons First

Master Codility's 14 lessons in order (Arrays, Stacks, Queues, etc.)

Each lesson has 3-4 problems that teach the pattern

These patterns appear in 80% of Round 2 problems

Then practice Codility challenges for hard problems

⚠ Codility Lessons Cover: Iterations, Arrays, Time Complexity, Counting Elements, Prefix Sums, Stacks & Queues, Greedy, Dynamic Programming, Fibonacci, Prime & Composite, Sieve of Eratosthenes, Euclidean, Lead & Silver.

Mistake 2: Ignoring Performance — O(n²) on n=100K Means Timeout = 0 Points

Codility auto-grades on correctness AND performance. A solution that's correct but slow scores ~50%.

Example: Finding Duplicates

Naive (O(n²)): For each element, check if it appears again. Correct but 50 points out of 100 on large inputs. Timeout.

Right (O(n)): Use a HashSet, add as you go, check before adding. 100 points.

Time Limits Rule of Thumb

• n ≤ 100: O(n³) OK
• n ≤ 1,000: O(n²) OK
• n ≤ 100K: O(n log n) REQUIRED
• n ≤ 1M: O(n) REQUIRED

Mistake 3: Not Handling Edge Cases

Codility hides test cases that you never see. You must anticipate:

Empty input: Array/string/list of size 0. Code should not crash.
Single element: Array of length 1. Off-by-one errors fail here.
All same: All elements are identical. Some algorithms assume variety.
Negatives: Negative numbers, negative indices (be careful with modulo).
Overflow: Sum of 100K elements of 1M each = 100 billion. Exceeds int.MaxValue (2.1B).

! Edge Case Discipline: After solving, manually test: empty, size 1, duplicates, negatives, max size. Codility tests all of these. Each failure = 10-20 points lost.

Mistake 4: Bad Time Management (Panic on Hard Problem)

You have 90 minutes for 3 problems. Don't spend 50 minutes on problem 1.

Time Distribution (90 min, 3 problems)

• Read all problems: 5 min
• Problem 1 (Easy): 15 min
• Problem 2 (Medium): 25 min
• Problem 3 (Hard): 45 min

If You're Stuck on Problem 3

• 20 min: Try brute force O(n²)
• 30 min: If no progress, submit partial
• Don't waste 45 min on 40% solution

Mistake 5: Not Using the Right Data Structures

Codility problems are specifically designed to reward correct data structure choices.

Problem Pattern	Right Data Structure	Why
Finding duplicates / frequency	HashSet / Dictionary	O(1) lookup, automatic counting
Finding min/max in stream	Heap / PriorityQueue	O(log n) insertion, auto-sorted
Matching brackets / reversal	Stack	LIFO perfect for nesting
BFS / level-order traversal	Queue	FIFO preserves distance
Prefix sums, cumulative logic	Array + one pass	O(n) space, O(n) time

✓ Data Structure Mastery: In the 60-day plan, dedicate a full week to just data structures. Dictionary, HashSet, Stack, Queue, PriorityQueue. Know insertion, deletion, search time complexity cold.

1.4

The Pass Score: ~210/300

Toptal's exact passing threshold is not public, but based on survivor reports and score distributions, you need approximately 210 out of 300 points across the 3 problems.

Scoring Breakdown

Each of the 3 Codility problems is scored out of 100:

Problem	Difficulty	Typical Points	Target Score	Strategy
Problem 1	Easy	100 (if perfect)	100/100	Aim for perfection. This is confidence building. 15 min, corner cases, optimize.
Problem 2	Medium	100 (if perfect)	100/100	Aim for perfection. Know the pattern (hash maps, prefix sums, greedy). 25 min.
Problem 3	Hard	0–100 (often partial)	10/100 (just submit)	Submit brute force. 45 min, but accept partial credit. Better 10% than 0%.

ℹ The Math: 100 (Easy) + 100 (Medium) + 10 (Hard) = 210. This is a realistic passing target. If you get perfect on Easy and Medium, you pass even with 0 on Hard. But aim for at least a partial attempt on Hard.

Scoring Mechanics (Codility)

Codility breaks each problem's score into two parts:

Correctness (usually 50%): Does your solution produce correct output for all test cases?
Performance (usually 50%): Does it meet time/memory limits?

Example Scoring

• Correct but slow (O(n²) on n=100K): ~50 points
• Correct and optimal: ~100 points
• Partially correct (few test cases pass): ~20-40 points
• Correct code but crashes on edge case: ~40 points

Rule of Thumb

If your solution passes 70% of test cases, you typically score 50-70 points. Missing performance = missing ~50 points on that problem.

⚠ Don't Chase Perfection on Hard: If you have 20 min left and Problem 3 is a DP hard, try a brute force O(n²) solution. Partial credit > 0 credit. Move on.

1.5

The 5 Golden Rules

These five principles separate people who pass from the 92.6% who don't. Internalize them.

Rule 1: Master Codility Lessons, Not Random LeetCode

Codility's 14 lessons are the curriculum. Complete them in order, understand the patterns, then supplement with hard problems from Codility's own Challenge problems and LeetCode.

1

Start with Codility Lessons (Iterations → BinSearch). These teach you the patterns Toptal tests.

2

Solve all practice problems in each lesson. Understand why the optimal solution uses that approach.

3

Move to Codility Challenges (hard problems). These are practice Toptal-style tests.

4

Use LeetCode for reinforcement on specific patterns (binary search, DP), not as your primary source.

Rule 2: Performance Is Everything

A correct but slow solution gets ~50 points. An incorrect optimal solution gets ~0. Your goal: correct AND optimal. Always choose a simpler, correct solution over a fancy, untested one.

2

1

Understand the input constraints. If n ≤ 100K, you need O(n) or O(n log n), not O(n²).

2

Use appropriate data structures. Don't use nested loops when a HashMap solves it in one pass.

3

Test on max input size mentally. If n = 100K and your code is O(n²), it will timeout.

4

Submit. Let Codility tell you if it times out. If it does, optimize further or try a different approach.

Rule 3: Handle ALL Edge Cases

Codility's test suite includes: empty, single element, all same, negatives, large numbers, duplicates. Test for all before submitting.

3

1

After writing code, list edge cases: empty, size 1, duplicates, negatives, boundary values.

2

Manually trace code on at least 3 edge cases. Write the expected output first, then verify.

3

Use assertions or print debugging. Make sure code doesn't crash and produces correct output.

4

Submit. If you fail hidden test cases, think about what you might have missed.

Rule 4: Use `long` for Sums and Products

If you're summing or multiplying large numbers, `int` will overflow. C#'s `int.MaxValue` is 2,147,483,647. Sum of 100K values of 1M each = 100 billion. Use `long`.

4

1

If the problem involves sums, products, or factorials, use long for accumulators.

2

Be wary of off-by-one errors with array indices. Always check bounds.

3

If multiplying before summing, consider overflow: (long)a * b not a * b.

4

Test edge case: max values. E.g., long.MaxValue + 1 wraps. Know the boundaries.

Rule 5: Time Management (15 + 25 + 50)

You have 90 minutes. Don't spend them all on Problem 1. Allocate: 15 min (Easy) + 25 min (Medium) + 50 min (Hard). If stuck on Hard after 45 min, submit what you have and move on.

5

1

Minutes 0–5: Read all 3 problems. Identify which is Easy/Medium/Hard.

2

Minutes 5–20: Solve Problem 1 (Easy). Test, optimize, submit.

3

Minutes 20–45: Solve Problem 2 (Medium). Test, optimize, submit.

4

Minutes 45–90: Problem 3 (Hard). Try optimal. If stuck at 75 min, brute force and submit for partial.

✓ The Golden Rule of Golden Rules: Internalize these five principles. They're not suggestions—they're the difference between passing and joining the 92.6%.

1.6

Complexity by Input Size

This table tells you which complexity class is acceptable for each input size. Memorize it. Use it to evaluate your solution before coding.

Input Size (n)	Acceptable Complexity	Acceptable Complexity (Alternative)	Too Slow	Rule of Thumb
n ≤ 100	O(n³)	O(n² log n)	O(n⁴)	Brute force fine. Can afford triple loops.
n ≤ 1,000	O(n²)	O(n² log n)	O(n³)	Double loops OK. Triple loops risky.
n ≤ 10,000	O(n log² n)	O(n√n)	O(n²)	Nested linear passes risky. Use sorting or binary search.
n ≤ 100,000	O(n log n)	O(n)	O(n² / 1000)	Must be linear or sort-based. Hash maps, single pass.
n ≤ 1,000,000	O(n)	O(n log n) if fast	O(n log n) if slow	Single pass only. Constant-time operations per element.
n ≤ 10,000,000+	O(n)	O(n) only	Everything else	Hyper-optimized. No allocations. Tight loops. Consider unsafe C#.

⚠ Testing the Table: When you see a problem with n ≤ 100K, immediately think: "O(n log n) or O(n)". If your solution is O(n²), you know it's wrong for the constraints. Adjust before coding.

How to Read This Table

The key is understanding operation count. Modern computers execute ~10^8 to 10^9 simple operations per second. So:

O(n²) with n=100K: 10^10 operations. Too slow (>1 sec).
O(n log n) with n=100K: 100K × 17 ≈ 1.7M operations. Fast (<1 ms).
O(n) with n=1M: 1M operations. Fast (<1 ms).

✓ Quick Estimation: If n=100K and your algorithm is O(n²), estimate 10 billion operations. Toptal has a 1-2 sec timeout. Your solution will fail. Think of a better approach.

1.7

C# Quick Reference for Codility

These are the most useful C# collections and methods for Codility problems. Know them cold.

Collections

Dictionary<K, V>

Use for: Frequency counting, mapping values

var count = new Dictionary<int, int>();
if (!count.ContainsKey(x)) count[x] = 0;
count[x]++;

Time: Insert O(1), lookup O(1), worst O(n)
Space: O(unique keys)

HashSet<T>

Use for: Checking membership, removing duplicates

var seen = new HashSet<int>();
if (seen.Contains(x)) { /* duplicate */ }
seen.Add(x);

Time: Insert O(1), contains O(1)
Space: O(unique values)

List<T>

Use for: Dynamic arrays, collecting results

var list = new List<int>();
list.Add(x);
var arr = list.ToArray();

Time: Add O(1) amortized, index O(1)
Space: O(count)

Stack<T>

Use for: LIFO (brackets, undo, DFS)

var stack = new Stack<int>();
stack.Push(x);
var top = stack.Pop();

Time: Push O(1), Pop O(1)
Space: O(depth)

Queue<T>

Use for: FIFO (BFS, level-order)

var queue = new Queue<int>();
queue.Enqueue(x);
var front = queue.Dequeue();

Time: Enqueue O(1), Dequeue O(1)
Space: O(width)

PriorityQueue<T, P>

Use for: Min/max heap, Dijkstra

var pq = new PriorityQueue<int, int>();
pq.Enqueue(val, priority);
var min = pq.Dequeue();

Time: Enqueue O(log n), Dequeue O(log n)
Space: O(count)

String & Array Methods

Method	Use Case	Time Complexity
`Array.Sort(arr)`	Sort array in-place	O(n log n)
`Array.BinarySearch(arr, val)`	Find index in sorted array	O(log n)
`StringBuilder.Append()`	Build strings efficiently (vs += loop)	O(1) amortized per append
`string.Contains()`	Check substring	O(n*m) worst, O(n) average
`string.Split()`	Split by delimiter	O(n)
`Enumerable.Distinct()`	Remove duplicates from sequence	O(n)

LINQ Tips

Avoid LINQ in hot loops: LINQ is convenient but slow. For Codility, write raw loops when performance matters.
Use .ToList() / .ToArray() carefully: These materialize the sequence. O(n) memory. Avoid in tight loops.
GroupBy is useful: arr.GroupBy(x => x).Select(g => g.Count()) for frequency counting.
OrderBy / OrderByDescending: O(n log n), equivalent to Array.Sort().

⚠ Performance Warning: LINQ is elegant but slow. If you have n=100K, avoid multiple LINQ chains. Write raw loops. Performance is 50% of the score.

1.8

60-Day Study Plan

You have 60 days — that's a massive advantage. Most people cram in 2 weeks and fail. With 60 days you can build deep understanding, practice 300+ problems, and walk in with supreme confidence. Follow this 8-week plan at 2 hours/day (weekdays) + 3 hours/day (weekends) = ~120 total hours.

Phase 1: Foundations & Big O (Week 1 — Days 1–7)

Build rock-solid fundamentals. No rushing. Understand WHY before HOW.

Day	Topic	What To Do	Hrs
Day 1	Big O & Complexity	Read DSA Book Ch 1. Understand O(1), O(n), O(n log n), O(n²). Practice estimating complexity from code.	2h
Day 2	Arrays Basics	Read DSA Book Ch 2. C# arrays, List<T>. Codility Lessons 1-2 (Iterations + Arrays). Solve all practice problems.	2h
Day 3	Strings & StringBuilder	Read DSA Book Ch 2 (strings section). Immutability, char[], StringBuilder. Solve 5 easy string problems.	2h
Day 4	Prefix Sums	Read DSA Book Ch 19. Codility Lesson 5. Solve: PassingCars, GenomicRangeQuery, MinAvgTwoSlice, CountDiv.	2h
Day 5	Counting Elements	Codility Lesson 4. Solve: FrogRiverOne, PermCheck, MissingInteger, MaxCounters. All must be 100%.	2h
Day 6 (Sat)	Practice Day	Solve Problem Bank Cat 1 (Arrays & Prefix Sums) — first 8 problems. Write every solution from scratch.	3h
Day 7 (Sun)	Review & Redo	Re-solve any problems you couldn't get on first try. Trace through solutions by hand on paper.	3h

✓Week 1 Milestone: Solve any easy Codility problem in under 10 minutes. Write prefix sum template from memory. Know array edge cases by heart.

Phase 2: Core Patterns (Week 2–3 — Days 8–21)

Master the 4 most important patterns: Hash Maps, Two Pointers, Sliding Window, Binary Search.

Day	Topic	What To Do	Hrs
Day 8	Hash Maps & HashSet	Read DSA Book Ch 5. Dictionary, TryGetValue, frequency counting. Solve: Two Sum, Valid Anagram.	2h
Day 9	Hash Map Problems	Problem Bank Cat 4: Group Anagrams, Top K Frequent, Subarray Sum K. Focus on complement pattern.	2h
Day 10	Two Pointers	Read DSA Book Ch 15. Sorted two pointers, fast/slow pointers. Solve: Container With Water, 3Sum.	2h
Day 11	Sliding Window	Read DSA Book Ch 15. EXPAND→SHRINK→UPDATE pattern. Solve: Longest Substring Without Repeating, MinAvgTwoSlice.	2h
Day 12	Sliding Window Practice	Problem Bank Cat 2: CountDistinctSlices, Minimum Window Substring, Max Consecutive Ones III.	2h
Day 13 (Sat)	Binary Search	Read DSA Book Ch 10. Standard, lower/upper bound, search on answer. Codility Lesson 14.	3h
Day 14 (Sun)	Binary Search Practice	Problem Bank Cat 3: Search Rotated Array, Find Peak, MinMaxDivision, NailingPlanks. All 100%.	3h
Day 15	Sorting Algorithms	Read DSA Book Ch 9. MergeSort, QuickSort, counting sort. Codility Lesson 6 (Sorting).	2h
Day 16	Sorting Problems	Problem Bank Cat 3: Merge Intervals, Kth Largest, Triangle, NumberOfDiscIntersections.	2h
Day 17	Stacks & Queues	Read DSA Book Ch 4. Codility Lesson 7. Solve: Brackets (100%), Fish (100%), Nesting, StoneWall.	2h
Day 18	Monotonic Stack	Problem Bank Cat 5: Next Greater Element, Largest Rectangle in Histogram, Daily Temperatures.	2h
Day 19	Stack Practice	Problem Bank Cat 5 remaining: Valid Parentheses, Min Stack, Basic Calculator, Trapping Rain Water.	2h
Day 20 (Sat)	Week 2-3 Review	Re-solve the 5 hardest problems from this phase. Can you solve each in <25 min?	3h
Day 21 (Sun)	MOCK TEST 1	Timed 90-minute mock test (Mock Test 1 from Problem Bank). Grade yourself honestly.	3h

✓Week 2-3 Milestone: Solve medium Codility problems in 20-25 min. Instantly recognize when to use hash map vs two pointers vs sliding window. Mock Test 1 score: aim for 200+/300.

Phase 3: Data Structures Deep Dive (Week 4–5 — Days 22–35)

Trees, Graphs, Heaps, Linked Lists. These appear in harder problems.

Day	Topic	What To Do	Hrs
Day 22	Linked Lists	Read DSA Book Ch 3. Singly/doubly linked, dummy node pattern. Solve: Reverse, Merge Two Sorted.	2h
Day 23	Linked List Problems	Problem Bank Cat 11: Cycle Detection, Remove Nth from End, Palindrome Linked List, Add Two Numbers.	2h
Day 24	Trees & BST	Read DSA Book Ch 6. Traversals (in/pre/post/level). DFS vs BFS on trees. Recursive thinking.	2h
Day 25	Tree Problems (Easy)	Problem Bank Cat 9: Max Depth, Symmetric Tree, Invert Binary Tree, Path Sum.	2h
Day 26	Tree Problems (Medium)	Problem Bank Cat 9: Validate BST, LCA, Level Order Traversal, Kth Smallest in BST.	2h
Day 27 (Sat)	Heaps & Priority Queues	Read DSA Book Ch 7. PriorityQueue<T,TPriority> in C#. Solve: Kth Largest in Stream, Merge K Lists.	3h
Day 28 (Sun)	Graph Fundamentals	Read DSA Book Ch 8. Adjacency list, BFS, DFS. Solve: Number of Islands, Clone Graph.	3h
Day 29	Graph BFS/DFS	Problem Bank Cat 6: Course Schedule, Word Ladder, Rotting Oranges. Track visited properly.	2h
Day 30	Graph Advanced	Dijkstra, topological sort. Problem Bank Cat 6: Cheapest Flights, Alien Dictionary, Network Delay.	2h
Day 31	Union-Find	Read DSA Book Ch 16 (Union-Find section). Problem Bank Cat 6: Number of Connected Components.	2h
Day 32	Codility Lessons 8-11	Leader, Maximum Slice, Prime/Composite, Sieve. Complete ALL practice problems. Target 100%.	2h
Day 33	Codility Lessons 12-17	Euclidean, Fibonacci, Binary Search, Caterpillar, Greedy, DP. Complete ALL remaining lessons.	2h
Day 34 (Sat)	Codility Review	Re-attempt any Codility problems where you scored <100%. Must get ALL 17 lessons to 100%.	3h
Day 35 (Sun)	MOCK TEST 2	Timed 90-minute mock test (Mock Test 2 from Problem Bank). Aim for 230+/300.	3h

✓Week 4-5 Milestone: All 17 Codility lessons at 100%. Comfortable with tree/graph DFS/BFS. Mock Test 2 score: aim for 230+/300. Recognize graph problems instantly.

Phase 4: Algorithm Paradigms (Week 6–7 — Days 36–49)

DP, Greedy, Backtracking, Divide & Conquer. These are what separates 200 from 280+ scores.

Day	Topic	What To Do	Hrs
Day 36	DP Fundamentals	Read DSA Book Ch 12. Top-down vs bottom-up. Solve: Climbing Stairs, House Robber, Coin Change.	2h
Day 37	1D DP Problems	Problem Bank Cat 8: LIS, Word Break, Decode Ways, Maximum Product Subarray, Perfect Squares.	2h
Day 38	2D DP Problems	Problem Bank Cat 8: Unique Paths, Edit Distance, LCS, 0/1 Knapsack. Draw DP tables by hand.	2h
Day 39	DP Advanced	State machine DP: Stock with Cooldown. Interval DP: Burst Balloons concept. Bitmask DP intro.	2h
Day 40	DP Practice	Solve 5 more DP problems from LeetCode (medium). Time yourself: 25 min max per problem.	2h
Day 41 (Sat)	Greedy Algorithms	Read DSA Book Ch 13. Problem Bank Cat 7: Jump Game, Gas Station, Task Scheduler, Partition Labels.	3h
Day 42 (Sun)	Greedy vs DP	When does greedy work? When must you use DP? Solve problems where the wrong choice fails.	3h
Day 43	Backtracking	Read DSA Book Ch 11. Subsets, Permutations, Combination Sum. Template: choose→explore→unchoose.	2h
Day 44	Backtracking Practice	N-Queens concept, Sudoku Solver concept, Word Search. Understand pruning for optimization.	2h
Day 45	Strings & Pattern Matching	Problem Bank Cat 10: Longest Palindromic Substring, Wildcard Matching, Minimum Window Substring.	2h
Day 46	Bit Manipulation	Read DSA Book Ch 17. Problem Bank Cat 12: Single Number, Counting Bits, Power of Two.	2h
Day 47	Intervals & Matrix	Problem Bank Cat 13: Merge Intervals, Meeting Rooms, Spiral Matrix, Rotate Image.	2h
Day 48 (Sat)	Hard Problem Day	Pick 3 hard problems (one DP, one graph, one design). Spend 40 min each. Review optimal solutions.	3h
Day 49 (Sun)	MOCK TEST 3	Timed 90-minute mock test (Mock Test 3 from Problem Bank). Target: 250+/300.	3h

✓Week 6-7 Milestone: Solve DP mediums in 25 min. Know greedy vs DP decision tree. Mock Test 3 score: aim for 250+/300. Pattern recognition is becoming automatic.

Phase 5: Polish, Mock Tests & Interview Prep (Week 8+ — Days 50–60)

This is where you go from "probably pass" to "definitely pass". Simulate real conditions. Prepare for all 4 rounds.

Day	Topic	What To Do	Hrs
Day 50	Weak Point Audit	Review all mock test failures. Which category do you fail most? Spend today on that category only.	2h
Day 51	Speed Drills	Solve 6 easy problems in 60 min (10 min each). Then 3 mediums in 75 min (25 min each). Build speed.	2.5h
Day 52	Edge Case Mastery	Read Pattern Cheatsheet. For each problem type, write down ALL edge cases. Empty, single, overflow, negative.	2h
Day 53	Codility Final Check	Re-attempt every Codility lesson problem. All must be 100%. Fix any that aren't. This is non-negotiable.	2h
Day 54	Random Problem Mix	Solve 5 random medium problems from LeetCode (don't pick the category). Practice pattern recognition.	2h
Day 55 (Sat)	MOCK TEST 4 (Full Sim)	90-minute timed test. Close everything except editor. No breaks. Score yourself. Target: 270+/300.	3h
Day 56 (Sun)	Live Coding Prep	Read Round 3 guide. Practice REACTO method with 2 problems. Talk through your solution out loud.	3h
Day 57	Take-Home Project Prep	Read Round 4 guide. Set up a .NET project template with Clean Architecture, DI, tests, Docker.	2h
Day 58	Communication Prep	Read Round 1 guide. Practice answering all questions aloud. Record yourself. Check English fluency.	2h
Day 59	FINAL MOCK TEST	Last timed 90-min simulation. This is your dress rehearsal. You should score 260+/300 consistently.	2h
Day 60	Rest & Light Review	Light review of cheatsheet and golden rules. No new problems. Sleep early. You're ready.	1h

⚠Days 55-60: If you're scoring 250+/300 on mock tests, you're ready. If below 210, repeat Phase 4 weak areas for another week before testing.

Daily Schedule Template

Each day follow this structure:

1

Theory/Reading (20-30 min): Read the relevant DSA Book chapter or Codility lesson. Understand the pattern conceptually before coding.

2

Guided Problems (45-60 min): Solve problems from the Problem Bank with solutions available. Read approach FIRST, try to code it, then check.

3

Independent Practice (30-45 min): Solve 1-2 problems on LeetCode/Codility WITHOUT looking at solutions. Time yourself.

4

Review & Spaced Repetition (15 min): Re-solve one problem from 3-5 days ago. Can you still do it? If not, add it to your "redo" list.

ℹTotal Study Time: 60 days × ~2h avg = 120 hours. That's nearly 3× what most candidates invest. Combined with structured practice and 5 mock tests, you'll be extremely well prepared.

Study Plan Adjustments

This plan assumes you know C# syntax and basic programming. Adjust if needed:

If weak in C#: Spend Week 1 entirely on C# syntax, collections, and LINQ. Shift everything else by one week.
If strong in DSA: Skip to Phase 2 on Day 1. Use the extra weeks for more mock tests and hard problems.
If failing mock tests after Week 7: Don't panic. You have time. Identify your 2 weakest categories and spend Days 50-55 exclusively on those.
If scoring 270+ by Week 6: You're ahead of schedule. Start Round 3-4 prep early. Maybe take the test sooner.

✓ The Flywheel Effect: By Day 14, you should see patterns. "Oh, this is a prefix sum problem." or "This is a two-pointer sliding window." That's the goal. Internalize the patterns.

→ Next Step: Read Part II: Round 1 — Communication Interview. Prepare your talking points for the video interview. Round 2 is the hardest, but Round 1 is the gatekeeper. Don't underestimate it.