Performance Engineering
Practice writing fast software. Learn to do it right.
400 $/mo
Tue / Fri, 18:30 (UTC+3)
start:
Aug 4, 2026
31 classes, 3 months
400 $/mo
Tue / Fri, 18:30 (UTC+3)
what's inside
Most performance problems don't live where people usually look — not just in algorithms. The root goes much deeper: in a poor understanding of modern CPU and GPU architectures, in how code actually executes and where exactly the processor loses time. Unnecessary allocations, poor data layout in memory, cache misses, branch predictor mispredictions, excessive context switches — each of these factors quietly eats away microseconds that add up into noticeable latency. And sometimes the processor could be doing useful work but is forced to sit idle, waiting on the OS kernel. This is why paradoxes emerge that break intuition: O(n) loses to O(n²), a HashMap with millions of entries falls behind a sorted array with binary search, and two threads run slower than one.
This is exactly why foundational knowledge in performance engineering becomes critical. The era of "free" performance is over: CPU clock speeds no longer grow the way they used to, memory is increasingly expensive and falling further behind the CPU. Hardware no longer forgives careless decisions — it bills you for them.
That's why we built this course. It takes you step by step from the level of bits and bytes up to operating systems — not as a surface-level overview or academic theory, but in depth, through practice and measurement. Why does the system behave this way? How do you measure it? What should you change in the code or architecture? The answers are built on one principle: don't guess — measure; don't "tweak" — explain; don't repeat others' advice — build your own mental model of what's happening under the hood.
The course is designed for middle and senior engineers who want to understand more deeply how code interacts with hardware, runtime, and the OS. For those who work or aspire to work where performance is not a nice to have but a baseline requirement: infrastructure, backend core, databases, ML systems, HFT, performance-sensitive services.
In an era when writing code has become easier than ever, the value of an engineer has shifted to where genuine understanding of what lies beneath the code is required. That understanding is what this course delivers — and it stays with you forever.
Curriculum
it will be hot
FOR ENGINEERS
CPU — what really happens when a processor executes code
You think a CPU is a machine that takes an instruction, executes it, then takes the next one. That hasn't been true since the 1990s. A modern processor is a pipeline.
• The most popular algorithm optimization techniques
• Sentinel and how it helps speed up code
• Are all CPU instructions equally fast?
• How Twitter and Facebook made production code 100x faster
• Nanosecond optimizations in High-frequency trading (HFT) companies
• Implementing a virtual machine as a Java Virtual Machine (JVM)
Python vs C. How many times and why does Python slow down code?
Cache — the most important abstraction people forget about
Your code doesn't work with RAM. It works with 32 KB of L1 cache. Every memory access that isn't in cache costs ~100 nanoseconds — in that time, the processor could have executed 300–400 instructions. This means the memory layout of your data can matter more than algorithmic complexity.
• Acceleration of production code due to memory hierarchy
• OOP is dead. Long live Data-Oriented Design
• Nuances of writing cache-friendly algorithms and data structures
• Operating system cache and its impact on File I/O implementation
• Tools for measuring cache performance
A Bit about Bytes — how data is represented in memory and why it matters
Every int, float, string — it's a set of bytes with a specific layout. If you don't know that layout, you can't predict the size of a structure, the speed of serialization, or the behavior of comparisons. The byte level is where your decisions have the most leverage.
• Bitmap indexes in databases
• Details of representation and operation with int, float, string types
• How does the variable length int work under the hood in Protobuf ?
• Unicode or how does Twitter limit the size of a tweet?
• Bit hacks
Memory — from malloc to garbage collector
new Object() — and the object appears in memory. But who decided at which address? Who will handle fragmentation? Who will free that memory? Behind every allocation stands an allocator — and its strategy determines whether your server holds up under load.
• We implement Memory allocator and Garbage collector
• Data Alignment. Impact on Memory and Performance
• The subtleties of implementing data structures in production
• Memory segments. How the Stack and Heap are arranged
Low-level optimizations — compiler, assembler, and hardware
The compiler does more for you than you think. But sometimes it can't — and that's when you need to understand what's happening one level down.
• Speedup through Instruction-level parallelism (ILP)
• Using SIMD and Branch prediction with examples
• Introduction to assembly language. Learn to write and read simple programs
• Reverse engineering
The operating system — abstractions you pay for
The OS gives you a convenient interface: files, processes, memory. But every syscall is a context switch. Every abstraction is overhead. Understanding the cost of these abstractions is the difference between "it works" and "it works fast."
• How Virtual Memory works and Page Tables under the hood
• How System calls and context switches work
• Key features OS provides for users
• How Page Faults can dramatically affect performance?
Processes — isolation, coordination, communication
A process is the basic unit of isolation in Unix. Understanding how processes are created, executed, and communicate with each other is the foundation for working with any server-side system.
• We are implementing our Shell
• Fork + Exec
• How coordination between processes is achieved through pipes
Multithreading and concurrency — from threads to event loop
"Add more threads" is not an optimization strategy. It's the beginning of a new class of problems: race conditions, deadlocks, priority inversion, starvation. Concurrency is a discipline of its own, where every decision involves a trade-off between throughput, latency, and correctness.
• Threads vs. Processes vs. Coroutines: an inside look
• We implement Event loop
• Synchronization objects and Data races. How to implement a mutex?
• We will write a Thread pool and fix many concurrency bugs
Instructor
it will be hot
FOR ENGINEERS
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
FOR ENGINEERS
reviews
what alumni say
What our
alumni say
Software Engineer @Meta
Vladyslav Kaplun
While taking the course, I received great satisfaction from the structured approach. The curator impresses with his ability to present information in an accessible and detailed manner. The knowledge gained from the course also has practical application in my work, which emphasizes the value of the education received.
ML Lead @Facebook
Sasha Savsunenko
It will be interesting and difficult, highly recommended to everyone! The course helped me to quickly understand complex code on a new project, understand the data structures and optimizations used. These are things every programmer should know.
Software Engineer @Microsoft
Valentyn Bochkarov
While preparing for the interview at FAANG, I took the Algorithms in Practice course, and later Performance Engineering. Now I can confidently say that both courses helped me get offers from Oracle and Microsoft.
Head Of Engineering @Artur'In
Vitalii Makovskyi
It was one of the most impressive learning experiences of my life. The teacher was able to convey deep knowledge of the subject and made the process exciting. During the study, you will challenge yourself and, equally important, meet interesting people.
Software Engineer @Meta
Roman Peregonchuk
The course is just great! It's a really cool way to gain new knowledge, meet interesting people, and as a bonus, prepare for technical interviews. One of my best investments, I can recommend it to everyone!
Software Engineer @Meta
Nazarii Ivanchuk
I really enjoyed learning about fundamental topics like algorithm optimization and caching. The chapters on improving CPU and memory efficiency were especially valuable. The material was presented in a clear and accessible way, and the knowledge I gained was immediately applicable.
Software Engineer @Amazon
Kyrylo Popyrko
The course is very well structured: it starts with high-level abstractions and gradually delves into details. Examples are based on real projects; interesting and practical homework assignments (I even had to defuse a bomb!). Worth every minute and every hryvnia invested.
Senior Software Engineer @SingleStore (ex MemSQL)
Viacheslav Ocheretnyi
I highly recommend this course and the platform in general!
Software Engineer @Google
Olha Voichyk
It was an interesting 3 months, during which I managed to gain and improve my knowledge of code optimization, virtual memory, and process interaction with the operating system. I would also like to note the thoughtful homework assignments — it was a great opportunity to practice what I learned.
Software Engineer @Brains Systems
Mark Firman
The depth and quality of the materials are unmatched by any other course. It is a truly unique experience that provides a deeper and more practical understanding of how computers work.
Software Engineer @Amazon
Yaroslav Borodaienko
A must-have for anyone who wants to delve into the ins and outs of a modern computer: how its CPU works, what memory is made of, and how the operating system manages processes. This knowledge will allow you to stand out both in technical interviews and during code reviews, providing useful advice. The course is well-structured and includes non-trivial homework assignments. The analysis of optimization cases in the Facebook and Twitter code bases is a particular pleasure.
Software Engineer @Google
Yaroslava Serdiuk
The course gave a deep understanding of the topic. It was interesting and informative. It is very gratifying that such initiatives are developing in Ukraine. I sincerely recommend it!
Senior Software Engineer @OpenText
Pavlo Surikov
This course offers an in-depth exploration of the low-level mechanics behind modern operating systems and CPU architectures, covering topics like caching, memory management, instruction-level performance, processes, multithreading, and concurrency.
I highly recommend it to developers who want to move beyond abstractions and learn to write optimized code grounded in a strong understanding of system internals.
Senior Software Engineer @ Lalafo
Sviatoslav Pikh
I especially liked the teaching approach, where I was encouraged to find the answer myself in small steps. Thanks to these courses, I discovered for myself how to continue learning at the Senior level. And live communication during lectures turned out to be much more effective than watching recorded videos on Udemy, Coursera, or YouTube.
Software Engineer @Google
Bohdan Tyshchenko
This program covered advanced techniques in performance analysis and system optimization.
Based on the quality of the content and the expertise of the instructor, Ivan Petrushenko, I highly recommend this course to any professional seeking to master the nuances of performance engineering.
Site reliability engineer, @Susquehanna International Group, LLP
Daniil Klieshchov
Ivan's lectures were the most valuable for me. There are many areas in computer science that you don't really think about when you're just writing code. Ivan shows exactly those aspects — how they work and why it's important to understand them if you want to optimize anything.
I was constantly asking questions, actively engaging, and that was really valuable. When someone has already been through that journey and explains complex things in a simpler way, it saves a lot of time on research and helps you build intuition faster. That, in my opinion, is one of the strongest sides of the course.
Senior Java Software Engineer @DXC Technology
Mykhailo Borysovskyi
A very strong and fundamental course that covers core Computer Science principles regardless of programming language. Throughout the program, we explored computer architecture, cache and memory optimizations, assembly language internals, and how the operating system manages processes, threads, address space, and resources — building a deep understanding of performance at the low level.
iOS Developer @Ring Ukraine
Iryna Didkovska
Great course — really glad Ivan created it and that I had the chance to join. I especially appreciated having access to lecture recordings to revisit at any time. The abundance of additional videos, links, and Ivan's notes broadened my perspective significantly and gave me a clear direction for what to watch and read next.
Lead Software Developer @GlobalLogic
Oleksii Kolesa
The course is well-structured and engaging, genuinely challenging. Plenty of hands-on practice.
communication that drives you
Twice weekly on Zoom — Tuesdays and Fridays at 6:30 PM, 1.5 hours each. All lectures recorded. Plus regular Q&A sessions with your instructor. Taught in Ukrainian. Supplementary materials in English.
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 connected.
No shallow slides — only deep dives into real production problems.
Certificates are earned: completed homework, active participation, tangible progress.
environment that energizes
We screen carefully — you'll learn among driven, motivated engineers.
Homework isn't exercises. These are real mini-projects mirroring production: optimization, deadlines, bugs, feedback, refactoring. You'll write serious code across Python, Java, Go, Assembly, C++. No fluff — pure engineering.
Your instructor won't leave you hanging. They explain until it clicks — third code review, staying late to debug, whatever it takes. We're here to push hard and level up.