algorithms in practice
Solve problems at the speed of thought.
start:
Feb 26, 2026
32 classes + 8 Q&A sessions
350 $/mo
what's inside
The fundamentals of algorithms and data structures transcend any specific tech stack. Master them, and your code becomes more robust, efficient, and elegant. You'll start seeing multiple solutions to every problem — and know which one to choose.
We'll dig into how algorithms power real production systems, build core concepts from the ground up, tackle hundreds of problems, and uncover the challenges behind popular libraries.
Fair warning: this course is challenging. Come ready to work hard — the results will exceed your expectations. Top graduates will get a unique opportunity: a technical interview with a FAANG engineer and detailed personal feedback.
curriculum
prepare yourself
- Heavy Hitters in DevOps: how to quickly identify requests generating more than X% of traffic
- Web server API performance analysis
- Asymptotic analysis of iterative and recursive algorithms
- Analysis of probabilistic algorithms
Analysis of algorithms
From API performance evaluation to probabilistic algorithm analysis.
Iterative search: when "head-on" is also a solution
Stress test writing techniques: how to test algorithms on edge cases
Two-pointer method: how to speed up brute-force
Prefix sums: optimizing calculations in arrays and matrices
Brute-force and Two pointers technique
From a naive solution to two-pointer optimization in databases and machine learning.
How to write error-free code using invariants
Linear search for Minesweeper and Run-length encoding
The root idea: a technique for speeding up code
Binary search in production systems and on unsorted data
Jump search and Galloping search: when binary search is not the only option
Lower bound on the complexity of the search task
Searching and Sqrt decomposition
The nuances of effective search in production and its connection to root optimization methods.
Convex Hull: How to Optimally Surround the Country with a 404 Wall
External sort: sorting gigabytes of data that don't fit in memory
Quick sort and Quick select: Dutch National Flag task
Relationship between Selection sort and Heap sort
Non-asymptotic optimizations Merge sort
Radix sort: how to sort 1,000,000 numbers faster than Quick sort
Scanline method: processing events in sorted order
Sorting and Divide-and-Conquer
From classic ideas to non-obvious optimizations and specialized methods for sorting gigabytes of data.
Dynamic Arrays: How to Make Them Fast
Shuffle task and its relationship with Reservoir Sampling on MapReduce
Union-Find: Fast union and search in sets
Implementing TTL support in Redis
Top-K of the most popular elements: effective approaches
Linked List and its variations for databases
Monotonic Stack and Circular Queue: Modifications of Classical Structures
XML validation and RPN for expression evaluation
Heap and Linear data structures
Application structures for storing, processing, and quickly accessing data using the example of Redis and SingleStore.
LRU Cache and optimal caching algorithms
Huffman Coding: How to Compress Data Without Loss
Optimal Event Planning: When Does the Greedy Approach Work?
Minimum Spanning Tree: the shortest path to connect everything
Greedy
How do greedy algorithms help create the most efficient caching and data compression strategies?
Implementing regular expressions: how does regex parsing work?
Combinatorial objects and their enumeration
Backtracking: How to Complete a Sudoku and Find Your Way Out of a Maze
Tail recursion and Tail Call optimization
Recursion
From tail recursion to regular expressions. How to use recursion for combinatorics and parsing.
How to compactly represent a hash table in memory
Collision Resolution. Chaining and Linear Probing
Bloom filter or what to do if the data does not fit into memory?
Rabin-Karp algorithm for the Pattern matching problem
Probabilistic algorithms and data structures
Let's implement our hash table and represent it compactly in memory.
The algorithm behind spell checkers
How LaTeX and Microsoft Word align text
Git diff and what does computational biology have to do with it?
How to win at Blackjack and "beautiful" reduce image size
Knapsack and the optimal path of the robot in the maze
Dynamic programming
How do text editors, Photoshop, and even card game strategies work?
DFS and BFS in action: implementing Web Crawler and PSTree commands in Linux
Cyclic dependencies and topological sorting
Finding the shortest paths: Dijkstra vs. Bellman-Ford
Binary Search Trees and how to easily balance them: AVL, Treap
Efficient implementation of autocompletion on Ternary Search Tree
Graphs and Trees
About the implementation of Web Crawler and text autocompletion on the site.
instructor:

Ivan Petrushenko
Engineering Lead y @SQUAD, Founder в @CS Osvita.
Former: @Dell Software Engineer, @Fiverr Senior Software Engineer, @Ring Machine Learning Engineer.
Ready? Take the first step
ready?
take the first step
I accept the terms of the Public Offer Agreement and consent to the processing of my personal data in accordance with the Privacy Policy.
reviews
what alumni say

Software Engineer @Spotify
Oleksandra Kulyk
This course is incredibly powerful. It works for both beginners and experienced engineers — thanks to the progressive difficulty of problems and algorithms, plus optional deep dives for extra practice. You'll develop a solid approach to tackling problems of any complexity. 100% recommend.

Software Engineer @Apple
Dmytro Pashchenko
It was here that I found the missing piece of the puzzle that filled the gap in my knowledge. It allowed me to gain a deeper understanding of the technologies I work with. For me, completing the courses was a real challenge, but the effort was worth it.

Senior Software Engineer @Netflix
Dmytro Kovalenko
After months of preparation and a couple of unsuccessful interviews, I decided to thoroughly study the basics. I got into school — it was exactly what I was missing. The result was not long in coming — I am in the company of my dreams. I advise you to undergo training to develop a habit of mastering new topics and solving increasingly complex tasks, which will help a lot in your work.

Software Engineer @Grammarly
Oleksii Zghurskyi
Great course, I recommend it. Gave a clear understanding of key topics and a lot of practical skills.

Senior Java Developer @UKEESS
Andrii Zaburiannyi
What immediately catches your eye is Ivan's incredibly cool structured presentation of the material. Before the course, I thought that it was almost impossible to understand algorithms, but during the lectures everything seemed to become clear on the fly. I believe that every developer will be able to fill some gap in their knowledge thanks to this course. Special respect for the homework and lecture notes. I had an incredible high from this cool course.

Senior Software Engineer @Coursera
Oleksandr Shen
Great course! I really enjoyed solving difficult homework assignments and working on tasks similar to production — it perfectly complements the theory and allows you to better understand the material covered.

Senior Engineer @Netflix
Maksym Kramarenko
I really enjoyed it. I definitely learned a lot of new things and remembered cool things that were forgotten in the whirlwind of working on everyday tasks. The difficulty was high enough to get a kick out of each solved task. We covered all the topics that interested me and even more!

Software Engineer @Lyft @ex-Google
Tymur Piriiev
Structured, original and fun presentation of complex topics. Very high-quality materials that complement the main lectures. Thoughtful homework assignments. My recommendation to everyone.

Software Engineer @Booking.com
Oleksandr Verboloz
The algorithmic course exceeded my expectations! The teacher is excellent at motivating and presents the material in an engaging way, which makes learning much easier. Thanks to the course, I finally got the base I was missing. I recommend CS Osvita to both beginners and professionals.

Vice President Software Engineer @JPMorgan
Ihor Khlaponin
Very methodical and structured approach that allowed to understand algorithms in general and why one or another is used in a specific case. It was interactive and very interesting, not boring like in regular lectures at the university. I also liked the element of the contest — it motivated to work harder to get a better result.

Senior Software Development Engineer @Amazon
Dmytro Kosmakov
Best algorithms course. No debate.

Software Engineer @IBM
Serhii Starovoit
I was very satisfied. Due to the change of project and work, time was short, and my knowledge of algorithms, to be honest, was heading towards zero, despite 7 years of experience in development. Therefore, the training required a lot of effort and time, but I never regretted signing up. The course helped me feel confident in interviews — and thanks to this, I successfully passed the interview at IBM. I highly recommend it!

Software Engineer @Grammarly
Pavlo Mykhailov
Very well structured and in-depth course that helps you understand how algorithms and data structures work «under the hood». Lots of practical exercises with real-world examples. Definitely recommend!

Software Engineer @Netflix
Vladyslav Posudevskyi
If you are still thinking, don't think. You have to take this course!
An incredible combination of theory and practice: classes are held live with attention to each student, and homework assignments are skillfully selected and help to deeply consolidate knowledge. I recommend it.

Senior Software Engineer @ Kinaxis
Yurii Biliaiev
The key feature of this course is the simple and understandable explanation of complex topics with a deep dive into the fundamentals. A course on how to become a better engineer. It helped me close the gaps in my knowledge and systematize the basic concepts. In addition, it is a great opportunity to meet like-minded people. The learning format is lively, dynamic and very practical. This course is significantly different from typical ones — deeper, clearer, more practical.

Principal Technical Architect @Adobe
Vasyl Nedvyha
Learning is not easy, like everything that has value. The course allowed me to deepen my knowledge in programming and find meaning in some technical topics that did not make much sense before. Due to a well-thought-out and fundamental learning plan — from mathematics to algorithms.
I also wanted to thank the entire CS Osvita team for organizing the learning process and improving the product.
what awaits
have fun and dive deep
environment that energizes
We screen carefully — you'll learn among strong, motivated peers. Skip homework? You're out.
Your instructor is always available. They'll explain until it clicks — whether that's a third code review or staying late after lecture.
That's how we work: learn and grow stronger together.
communication that drives you
Twice-weekly Zoom sessions — Wednesdays 6:30 PM, Saturdays 10:00 AM, 1.5 hours each. Extra Q&A sessions with your instructor. All lectures recorded.
Hands-on assignments with clear deadlines. You'll write plenty of code — language is your choice.
Slack is our hub for discussions, clever test cases, and top company referrals.
format that works
Constant feedback in Slack, lectures, and Q&A — we're always here.
No surface-level slides — just in-depth analysis of real production challenges.
Certificates require real results: completed assignments, active discussions, measurable growth.