Model Online / On-Site
Duration
Modules 5 modules

Course Objective & Scope

Many production performance incidents stem from loops that degrade to O(n²) as data grows, poor collection choices or excessive memory allocations. Rather than academic proofs, this course builds the practical judgment needed to pick the right data structure and algorithm in everyday backend work.

Time and space complexity (Big-O), arrays, linked lists, stacks/queues, hash tables, trees (BST, B-Tree, Trie), heaps/priority queues, graph algorithms, sliding window/two-pointer techniques and CPU cache effects are coded through real system scenarios such as rate limiters, LRU caches, autocomplete and dependency resolution.

Who Should Attend?

  • Backend and full-stack developers building performance-sensitive services
  • Engineers diagnosing CPU and memory bottlenecks on large datasets
  • Developers strengthening their algorithmic problem-solving and code review depth
  • Prerequisite: basic programming proficiency in any language (Java, C#, Python, Go, JS/TS)

Key Takeaways

  • Analyse the worst-case and amortised time and space complexity of code paths
  • Choose accurately between List, Set, Map/Dictionary, Deque and PriorityQueue types
  • Understand the B-Tree, LSM-Tree and Trie structures behind database indexes and search engines
  • Apply graph traversal, topological sort and shortest-path algorithms to business and dependency problems
  • Spot hidden O(n²) bottlenecks in production code and refactor them into linear or logarithmic solutions

Curriculum

Complexity Analysis and Linear Data Structures
  • Big-O, Big-Omega, Big-Theta, amortised analysis and CPU cache locality
  • Dynamic arrays, linked lists, Stacks, Queues and Ring Buffers/Deques
  • Array and stream processing with Two Pointers and Sliding Window techniques
Hash Tables and Cache Structures
  • Hash functions, collision resolution, load factor and rehashing costs
  • Eliminating O(n²) nested lookups down to O(n) using Sets and Maps
  • Building an LRU Cache and a Rate Limiter with a HashMap and doubly linked list
Trees, Index Structures and Heaps (Priority Queues)
  • Binary search trees, balanced trees and B-Trees / LSM-Trees in databases
  • Text search, routing and autocomplete with Tries (Prefix Trees)
  • Task scheduling and Top-K queries using Binary Heaps / Priority Queues
Graph Algorithms and Dependency Modelling
  • Adjacency list vs matrix representations, BFS and DFS traversals
  • Workflow and package dependency resolution with topological sort and cycle detection
  • Shortest paths with Dijkstra and connectivity with Union-Find (Disjoint Set)
Searching, Sorting, Dynamic Programming and Code Optimisation
  • Binary Search variations (search on answer space) and hybrid sorting (Timsort/Introsort)
  • Recursion, memoization and practical dynamic programming patterns
  • Benchmarking and algorithmic refactoring workshop on real production-style code

Other Courses in This Category

  • Modern Web and API Development with PHP 8 and Laravel

    Modern PHP 8.x type system and OO features, Composer/PSR standards, MVC and REST API development with Laravel (or Symfony), Eloquent ORM, queues, security and Pest/PHPUnit testing — bringing PHP teams up to modern engineering standards.

    Web Development – Backend Corporate
    Live Course
    5 modules
    View
  • Java and Spring Boot Backend Development

    Build REST APIs with Spring Boot 3, data access with Spring Data JPA, authentication with Spring Security and tests with Testcontainers — a production-ready service skeleton for Java backend developers.

    Web Development – Backend Corporate
    Live Course
    6 modules
    View
  • .NET and ASP.NET Core Web API Development

    ASP.NET Core Web API and Minimal APIs, Entity Framework Core, dependency injection, middleware and authentication — for teams building maintainable, testable backend services on .NET 8/9.

    Web Development – Backend Corporate
    Live Course
    5 modules
    View
  • Node.js and NestJS Backend Development

    Modular backends with TypeScript and NestJS: controllers, providers, dependency injection, data access with Prisma/TypeORM, guards and pipes, testing with Jest — a scalable service structure for Node.js teams.

    Web Development – Backend Corporate
    Live Course
    5 modules
    View
  • REST API Design Best Practices

    Resource modelling, HTTP methods and status codes, versioning, pagination, error format (RFC 9457), idempotency and contract-first design with OpenAPI — for teams publishing consistent, documented APIs.

    Web Development – Backend Corporate
    Live Course
    5 modules
    View
  • Event-Driven Architecture with Kafka and Messaging

    Events vs commands vs messages, asynchronous communication with Apache Kafka and RabbitMQ, the outbox pattern, idempotent consumers, sagas and schema registry — for teams designing loosely coupled, scalable systems.

    Web Development – Backend Corporate
    Live Course
    5 modules
    View

Get in touch