Skip to main content

// data-structures-algorithms

Data Structures & Algorithms tutoring, one-on-one.

DSA and problem-solving for coding interviews.

languages & code 3 levels from $75/hr 1-on-1 online
First session free100% online, 1-on-1From $75/hr

// choose your starting point

Data Structures & Algorithms levels

Start where you are — each level maps to a different point on the journey. We confirm the right one together in your free first session.

$75/hr

DSA Foundations

Core data structures, from scratch.

Who it's forFor someone who can write basic code (Python or C++) and wants to build the core data-structure foundation that every coding interview tests, from scratch.

Build the foundation every coding interview tests: Big-O analysis and the core data structures — arrays, hash maps, stacks, queues and linked lists…

What you'll be able to do

  • Analyse the time and space complexity (Big-O) of your own code and compare approaches.
  • Solve array and string problems using the standard idioms instead of brute force.
  • Recognise when a hash map turns an O(n^2) problem into O(n), and implement it.
  • Implement and use stacks, queues, and linked lists, and explain their trade-offs.

Sounds familiar?

  • I can code, but Big-O analysis makes my eyes glaze over — I can't say if my solution is efficient.
  • I freeze on array and string problems because I never learned the standard techniques.
  • I know hash maps exist but I don't have the instinct for when reaching for one is the answer.
  • Linked lists, stacks, and queues feel abstract — I've never implemented or really used them.
Big-O & complexityArrays & stringsHash mapsStacks & queuesLinked lists
Python or C++LeetCodeDebugger / IDEStandard library (dict/list, C++ STL)
Book this level
$100/hr

Algorithms & Patterns

Trees, graphs, the patterns that matter.

Who it's forFor someone solid on core data structures who now needs the algorithmic patterns — trees, graphs, recursion, and the reusable techniques that unlock most interview problems.

Learn the algorithm patterns that unlock LeetCode-style problems: trees, graphs, recursion, and techniques like two-pointers, sliding window and an…

What you'll be able to do

  • Traverse and solve problems on trees and graphs (BFS/DFS) with confidence.
  • Write and reason about recursive and backtracking solutions, and know when to use them.
  • Recognise and apply the two-pointer and sliding-window patterns to the problems they fit.
  • Solve introductory dynamic-programming problems by spotting overlapping subproblems.

Sounds familiar?

  • I can do easy problems but freeze the moment a question involves a tree or a graph.
  • Recursion melts my brain — I can't trace it or trust it, and backtracking is worse.
  • I solve each problem from scratch with no pattern, so a slightly different version stumps me again.
  • Everyone says "two pointers" and "sliding window" like they're obvious; to me they're not.
Trees & graphsRecursion & backtrackingSorting & searchingTwo pointers / sliding windowDP intro
Python or C++LeetCodeShared editor / whiteboardStandard library (collections, heaps)
Book this level
$130/hr

Interview-Ready

DP, system design, mock interviews.

Who it's forFor someone who knows the core patterns and is now targeting top tech roles — mastering dynamic programming and advanced graphs, an intro to system design, and realistic mock interviews.

Get interview-ready for top tech roles: master dynamic programming and advanced graph algorithms, get an introduction to system design, and practise…

What you'll be able to do

  • Derive dynamic-programming solutions yourself by defining state and transitions, not just memorising.
  • Apply advanced graph algorithms (Dijkstra, union-find, topological sort) to harder problems.
  • Reason through an introductory system-design question (scaling, databases, caching) with structure.
  • Perform under realistic mock interviews with live feedback on communication and code.

Sounds familiar?

  • Dynamic programming is my wall — I can follow a solution but can't derive one under pressure.
  • Advanced graph problems (shortest paths, union-find, topological sort) still throw me.
  • I've never done a system-design round and the open-endedness terrifies me.
  • I can solve problems alone but fall apart explaining my thinking out loud in a real interview.
Dynamic programmingGraph algorithmsSystem design basicsMock interviewsOptimisation
Python or C++LeetCodeMock-interview format (timed)Whiteboarding tool
Book this level

//what's included

How a Data Structures & Algorithms session works

Every subject runs on the same method — a live, hands-on hour built so the learning sticks, with everything you make saved and yours to keep.

Live co-op coding

We work in one shared editor with you driving — you write the code or derive the maths while I steer in real time, not by watching slides.

Saveable whiteboard

Every diagram and derivation is sketched on a shared whiteboard you keep — the canvas is saved and yours to revisit after the hour.

Written recap

You leave with a written summary of what changed and one or two things to practise, so the session keeps working after we hang up.

Off-class help

Stuck between sessions? Send the error or the question and get unblocked — support does not stop the moment the call ends.

Assignments & checkpoints

We close each hour with a checkpoint you attempt solo, so we both see it actually landed — and loop back before the time runs out if it did not.

Your class archive

Code, whiteboards and recaps live in one place you can return to — a growing folder of everything we have built together.

Want the minute-by-minute anatomy of a real hour? See how it works →

// what to expect

Honest about how it goes

No guarantees, no fixed curriculum — just a specific, repeatable way of working that gets you unstuck on Data Structures & Algorithms.

Built around your goal

There is no fixed syllabus to keep pace with. The hour is built backwards from the one thing you need — a failing assignment, a concept that will not stick, a project to ship.

Diagnosed, not re-taught

We find the precise step where it breaks down instead of re-covering what you already know — so the time goes to the gap that actually matters.

You drive, I steer

You do the work in real time while I guide — that is how it sticks. You leave able to do it yourself, not just having watched me do it.

Honest pace & pricing

You only pay for the levels and pace that fit. We agree the plan together after the free first session — no packages you do not need.

// faq

Frequently asked questions

About Data Structures & Algorithms tutoring and how sessions work.

Is the first Data Structures & Algorithms session really free?

Yes. Your first session is complimentary so you can experience the teaching style, talk through your goals, and decide whether to continue — no credit card required upfront.

How much does Data Structures & Algorithms tutoring cost?

Sessions start at $75/hour, and multi-session packages are available at a discount. You only pay for the levels and pace that fit your goals — we agree on a plan together after the free first session.

How are Data Structures & Algorithms sessions delivered?

All sessions are 1-on-1 and 100% online over video, with screen sharing and a shared editor or whiteboard. Sessions are typically 60–90 minutes and scheduled around your availability.

Which Data Structures & Algorithms level should I start at?

It is set by where you are now, not a fixed curriculum. In the free first session we map your background to the right starting level and adjust the pace as you progress.

Who is teaching the sessions?

Every session is taught directly by Ali Jabbary, M.Sc., P.Eng. — not a rotating pool of tutors. You work with the same instructor throughout.

Ready to start Data Structures & Algorithms?

Your first session is free, with no credit card required. Book a time that suits you and we'll map out exactly where to begin.

from $75/hr · 1-on-1 · 100% online · taught by Ali

Book a free callMessage Ali