<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:video="http://www.google.com/schemas/sitemap-video/1.1">
<url>
  <loc>https://interviewready.io/learn/system-design-course/building-an-ecommerce-app-1-to-1m/1-what-is-system-design</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1027797698/poster.jpg</video:thumbnail_loc>
    <video:title>#1: System Design, Requirements and APIs</video:title>
    <video:description>Introduces system design through an e-commerce example: a T-shirt seller outgrows Shopify&apos;s payment and delivery integrations, leading to custom pages, a server and simple JSON APIs.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1027797698/720p.mp4</video:content_loc>
    <video:duration>500</video:duration>
    <video:publication_date>2024-11-08T20:33:04.129Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/system-design-course/building-an-ecommerce-app-1-to-1m/2-hosting-the-application-servers</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1027797823/poster.jpg</video:thumbnail_loc>
    <video:title>#2: Hosting: Server or Serverless</video:title>
    <video:description>Compares self-hosting on a spare computer with renting cloud compute, then weighs managed servers against serverless for a small e-commerce startup and explains why serverless is chosen.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1027797823/720p.mp4</video:content_loc>
    <video:duration>267</video:duration>
    <video:publication_date>2024-11-09T13:36:35.200Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/system-design-course/building-an-ecommerce-app-1-to-1m/3-webpages-and-cdn</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1027806031/poster.jpg</video:thumbnail_loc>
    <video:title>#3: CDNs, DNS and Choosing a Database</video:title>
    <video:description>Explains serving static pages from a CDN such as CloudFront with S3 as the source, keeping dynamic data on the server, resolving a custom domain through DNS and Route 53, and choosing a startup database.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1027806031/720p.mp4</video:content_loc>
    <video:duration>580</video:duration>
    <video:publication_date>2024-11-09T13:35:05.340Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/system-design-course/building-an-ecommerce-app-1-to-1m/4-debugging-in-the-trenches</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1027839958/poster.jpg</video:thumbnail_loc>
    <video:title>#4: Logging, Monitoring and Single Points of Failure</video:title>
    <video:description>Shows how request-level logging with CloudWatch and dashboards such as Google Analytics speed up debugging, then identifies single points of failure in the store&apos;s architecture and how to handle them.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1027839958/720p.mp4</video:content_loc>
    <video:duration>445</video:duration>
    <video:publication_date>2024-11-15T13:11:42.585Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/how-do-i-use-this-course/what-do-we-offer</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1236748669/poster.jpg</video:thumbnail_loc>
    <video:title>What do we offer?</video:title>
    <video:description>Describes the course: a turn based game engine built to teach DRY, SOLID and patterns, four machine coding problems, quizzes and diagrams, and a final test.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1236748669/720p.mp4</video:content_loc>
    <video:duration>75</video:duration>
    <video:publication_date>2026-10-17T04:41:35.250Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/building-a-game-engine/the_need_for_good_coding_practices</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1037440844/poster.jpg</video:thumbnail_loc>
    <video:title>What is Low Level Design?</video:title>
    <video:description>Defines low level design as a mix of design and coding and introduces readability, extensibility and correctness as the three measures of good code.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1037440844/720p.mp4</video:content_loc>
    <video:duration>204</video:duration>
    <video:publication_date>2023-12-15T23:23:45.304Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/building-a-game-engine/introduction-to-low-level-design-series</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/895434873/poster.jpg</video:thumbnail_loc>
    <video:title>Introduction to Low Level Design Series</video:title>
    <video:description>Introduces the low level design series, which covers guiding principles such as SOLID, inheritance and composition, and design patterns, through building a turn-based game AI engine.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/895434873/720p.mp4</video:content_loc>
    <video:duration>131</video:duration>
    <video:publication_date>2023-12-17T03:38:43.639Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/building-a-game-engine/setting_requirements_and_objects</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891330733/poster.jpg</video:thumbnail_loc>
    <video:title>Setting Requirements and Objects</video:title>
    <video:description>A turn-based game AI engine is written without any upfront design, defining start, move and isComplete APIs and a tic-tac-toe board whose win-checking logic grows into nested loops and conditions.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891330733/720p.mp4</video:content_loc>
    <video:duration>784</video:duration>
    <video:publication_date>2023-12-15T19:35:44.430Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/building-a-game-engine/api_and_package_structuring</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891331038/poster.jpg</video:thumbnail_loc>
    <video:title>API and Package Structuring</video:title>
    <video:description>The tic-tac-toe game engine is refactored by moving classes into separate files and packages, turning the main class into a GameEngine API, and replacing direct array access with a getter.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891331038/720p.mp4</video:content_loc>
    <video:duration>590</video:duration>
    <video:publication_date>2023-12-15T19:36:10.321Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/building-a-game-engine/parent_vs._base_class_functions</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891331242/poster.jpg</video:thumbnail_loc>
    <video:title>Parent vs. Base class functions</video:title>
    <video:description>The game engine refactor continues by placing getCell and setCell in TicTacToeBoard rather than the base Board class, adding a Cell class, and implementing start and move for tic-tac-toe.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891331242/720p.mp4</video:content_loc>
    <video:duration>248</video:duration>
    <video:publication_date>2023-12-15T19:36:25.146Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/building-a-game-engine/setting_the_main_method</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891331354/poster.jpg</video:thumbnail_loc>
    <video:title>Setting the main method</video:title>
    <video:description>A Main class is written to play tic-tac-toe through the game engine, looping between user moves and a naive computer move that picks the first empty cell until the game is complete.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891331354/720p.mp4</video:content_loc>
    <video:duration>202</video:duration>
    <video:publication_date>2023-12-15T19:36:38.130Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/building-a-game-engine/debugging_the_code</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891331439/poster.jpg</video:thumbnail_loc>
    <video:title>Debugging the code</video:title>
    <video:description>The tic-tac-toe engine is run and debugged, fixing null pointer exceptions, an incorrect diagonal check and a missing column break, then tested on rows, columns and both diagonals.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891331439/720p.mp4</video:content_loc>
    <video:duration>573</video:duration>
    <video:publication_date>2023-12-15T19:36:54.946Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/single-responsibility-principle/defining_responsibilities_of_ai_and_game_classes</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891331604/poster.jpg</video:thumbnail_loc>
    <video:title>Defining responsibilities of AI and Game classes</video:title>
    <video:description>Introduces the single responsibility principle from SOLID and uses it to split a game engine into game, AI and rule responsibilities.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891331604/720p.mp4</video:content_loc>
    <video:duration>584</video:duration>
    <video:publication_date>2023-12-15T19:37:05.510Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/single-responsibility-principle/unit_tests</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891331771/poster.jpg</video:thumbnail_loc>
    <video:title>Unit Tests</video:title>
    <video:description>Writes JUnit tests for a tic tac toe game by behaviour, with a shared setup, helper functions for wins and a test for the computer winning.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891331771/720p.mp4</video:content_loc>
    <video:duration>352</video:duration>
    <video:publication_date>2023-12-15T19:37:18.204Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/single-responsibility-principle/benefits_of_single_responsibility_principle</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891331913/poster.jpg</video:thumbnail_loc>
    <video:title>Benefits of Single Responsibility Principle</video:title>
    <video:description>Reviews tic tac toe tests for readability and extensibility and summarises what the single responsibility principle brought to the game design.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891331913/720p.mp4</video:content_loc>
    <video:duration>301</video:duration>
    <video:publication_date>2023-12-15T19:37:36.168Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/exploring-moves-for-the-ai/looking_for_a_smart_ai</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891332023/poster.jpg</video:thumbnail_loc>
    <video:title>Looking for a Smart AI</video:title>
    <video:description>Explains the O in SOLID using the AI engine of a game: add a smarter move algorithm behind one suggest move function without changing the callers.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891332023/720p.mp4</video:content_loc>
    <video:duration>340</video:duration>
    <video:publication_date>2023-12-15T19:38:02.327Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/exploring-moves-for-the-ai/the_need_for_stateless_move_exploration</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891332156/poster.jpg</video:thumbnail_loc>
    <video:title>The need for stateless move exploration</video:title>
    <video:description>Builds attacking and defensive move checks for the AI engine and explains why move exploration should work on a copy of the board instead of undoing moves.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891332156/720p.mp4</video:content_loc>
    <video:duration>448</video:duration>
    <video:publication_date>2023-12-15T19:38:18.597Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/exploring-moves-for-the-ai/prototype_design_pattern</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891332338/poster.jpg</video:thumbnail_loc>
    <video:title>Prototype Design Pattern</video:title>
    <video:description>Adds a copy method to the Tic-Tac-Toe board as the prototype pattern, avoids copy by reference bugs, and rewrites tests to force opponent moves.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891332338/720p.mp4</video:content_loc>
    <video:duration>809</video:duration>
    <video:publication_date>2023-12-15T19:38:32.034Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/dont-repeat-yourself/dry_dont_repeat_yourself</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891332647/poster.jpg</video:thumbnail_loc>
    <video:title>DRY: Dont Repeat Yourself</video:title>
    <video:description>Shows how to refactor a 90 line getGameState method with the DRY principle by merging the row and column checks into shared logic.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891332647/720p.mp4</video:content_loc>
    <video:duration>911</video:duration>
    <video:publication_date>2023-12-15T19:38:46.545Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/dont-repeat-yourself/iterator_design_pattern</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891333058/poster.jpg</video:thumbnail_loc>
    <video:title>Iterator Design Pattern</video:title>
    <video:description>Tries a Java iterator with has next and next to replace a complex traversal, then finds that a bi function suits board traversal better and shortens the diagonals.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891333058/720p.mp4</video:content_loc>
    <video:duration>443</video:duration>
    <video:publication_date>2023-12-15T19:38:58.938Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/dont-repeat-yourself/dry_extracting_common_pieces</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891333227/poster.jpg</video:thumbnail_loc>
    <video:title>DRY: Extracting Common Pieces</video:title>
    <video:description>Applies the DRY principle to duplicated streak-finding loops, extracting a traverse lambda, and warns that fewer lines can still mean more rigid code.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891333227/720p.mp4</video:content_loc>
    <video:duration>416</video:duration>
    <video:publication_date>2023-12-15T19:39:18.823Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/open-closed-principle/new_feature_request_find_forks</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891333365/poster.jpg</video:thumbnail_loc>
    <video:title>New feature request: Find Forks!</video:title>
    <video:description>Takes a feature request to detect forks in tic tac toe and shows why adding it to the get state function makes code harder to read, test and extend.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891333365/720p.mp4</video:content_loc>
    <video:duration>730</video:duration>
    <video:publication_date>2023-12-15T19:39:39.647Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/open-closed-principle/building_a_rule_engine</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891333610/poster.jpg</video:thumbnail_loc>
    <video:title>Building a Rule Engine</video:title>
    <video:description>Turns get state into a rule engine: each row, column and diagonal check becomes a rule object in a list, so rules can be added or removed without changing get state.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891333610/720p.mp4</video:content_loc>
    <video:duration>534</video:duration>
    <video:publication_date>2023-12-15T19:39:57.229Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/open-closed-principle/builder_design_pattern</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891338389/poster.jpg</video:thumbnail_loc>
    <video:title>Builder Design Pattern</video:title>
    <video:description>Refactors game info to depend on primitives, shows how adding a field doubles the constructors, and replaces them with a builder where each field has a setter.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891338389/720p.mp4</video:content_loc>
    <video:duration>416</video:duration>
    <video:publication_date>2023-12-15T19:40:10.849Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/open-closed-principle/summary_open-closed_principle</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891338535/poster.jpg</video:thumbnail_loc>
    <video:title>Summary: Open-Closed Principle</video:title>
    <video:description>A short summary of the open-closed principle: add more rules or functionality to a system without modifying its internal code.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891338535/720p.mp4</video:content_loc>
    <video:duration>49</video:duration>
    <video:publication_date>2023-12-15T19:40:23.877Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/liskov-substitution-principle/new_feature_request_timers</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891338569/poster.jpg</video:thumbnail_loc>
    <video:title>New feature request: Timers!</video:title>
    <video:description>Adds a timer requirement to the game and shows why a game config held by the game works better than timed and leisure game subclasses.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891338569/720p.mp4</video:content_loc>
    <video:duration>480</video:duration>
    <video:publication_date>2023-12-15T19:41:02.766Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/liskov-substitution-principle/encapsulating_responsibilities_in_objects</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891338709/poster.jpg</video:thumbnail_loc>
    <video:title>Encapsulating responsibilities in objects</video:title>
    <video:description>Adds time limits to a game by storing each player&apos;s time used on a player object, passing a timestamp with each move, and deciding against a rule engine.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891338709/720p.mp4</video:content_loc>
    <video:duration>607</video:duration>
    <video:publication_date>2023-12-15T19:41:17.006Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/liskov-substitution-principle/extracting_nested_objects</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/894495994/poster.jpg</video:thumbnail_loc>
    <video:title>Extracting Nested Objects</video:title>
    <video:description>Refactors rule engine code by extracting a nested map of rules into a rule set object, then shows how a getSymbol method on the base board class violates Liskov substitution.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/894495994/720p.mp4</video:content_loc>
    <video:duration>752</video:duration>
    <video:publication_date>2023-12-15T19:41:32.922Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/7-interface-segregation-and-dependency-inversion/having_multiple_ai_personalities</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/894496584/poster.jpg</video:thumbnail_loc>
    <video:title>Having Multiple AI personalities</video:title>
    <video:description>Adds an optimal AI player to the tic tac toe engine, simplifies move signatures to return cells, extends the builder with a fork cell, and finds that ordered rules need a better structure.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/894496584/720p.mp4</video:content_loc>
    <video:duration>691</video:duration>
    <video:publication_date>2023-12-15T19:41:48.836Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/7-interface-segregation-and-dependency-inversion/singleton_and_null_object_design_pattern</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891438236/poster.jpg</video:thumbnail_loc>
    <video:title>Singleton and Null Object Design Pattern</video:title>
    <video:description>Builds offensive and defensive placement classes in a state manager package and applies the singleton pattern, Optional and the null object idea in Java.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891438236/720p.mp4</video:content_loc>
    <video:duration>545</video:duration>
    <video:publication_date>2023-12-15T19:42:01.390Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/7-interface-segregation-and-dependency-inversion/chain_of_responsibility_pattern</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891438482/poster.jpg</video:thumbnail_loc>
    <video:title>Chain of Responsibility Pattern</video:title>
    <video:description>Cleans up duplicated placement code with a utils singleton helper and an explicit chain, explaining the chain of responsibility pattern in the game AI.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891438482/720p.mp4</video:content_loc>
    <video:duration>700</video:duration>
    <video:publication_date>2023-12-15T19:42:24.805Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/7-interface-segregation-and-dependency-inversion/interface_segregation_principle</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891438863/poster.jpg</video:thumbnail_loc>
    <video:title>Interface Segregation Principle</video:title>
    <video:description>Shows interface segregation using a board interface and a sub interface for boards with cells, which removes generics from the rule engine.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891438863/720p.mp4</video:content_loc>
    <video:duration>260</video:duration>
    <video:publication_date>2023-12-15T19:42:49.027Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/7-interface-segregation-and-dependency-inversion/dependency_inversion_principle</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891438994/poster.jpg</video:thumbnail_loc>
    <video:title>Dependency Inversion Principle</video:title>
    <video:description>Explains the dependency inversion principle using a generic cell board instead of concrete boards, and recaps the five SOLID principles.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891438994/720p.mp4</video:content_loc>
    <video:duration>178</video:duration>
    <video:publication_date>2023-12-15T19:43:03.028Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/memory-and-code-optimizations/new_feature_request_undo_moves_with_momento</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891439072/poster.jpg</video:thumbnail_loc>
    <video:title>New feature request: Undo Moves with Momento!</video:title>
    <video:description>Adds a history of moves and an undo feature to a game board by storing a copy of the board for each move, which is the memento design pattern.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891439072/720p.mp4</video:content_loc>
    <video:duration>639</video:duration>
    <video:publication_date>2023-12-15T19:43:47.695Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/memory-and-code-optimizations/proxy_and_flyweight_design_pattern</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891439434/poster.jpg</video:thumbnail_loc>
    <video:title>Proxy and Flyweight Design Pattern</video:title>
    <video:description>Cuts memory use by storing a board proxy, a string representation, and creating the real board lazily, then compares the proxy pattern with a plain constructor.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891439434/720p.mp4</video:content_loc>
    <video:duration>621</video:duration>
    <video:publication_date>2023-12-15T19:44:15.532Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/memory-and-code-optimizations/the_labyrinth_five_level_deep_for_loops</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891439931/poster.jpg</video:thumbnail_loc>
    <video:title>The Labyrinth: Five Level Deep For-Loops!</video:title>
    <video:description>Refactors the deeply nested fork detection code in a tic-tac-toe rule engine, using a symbol class, composition for cells and defensive and offensive placements.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891439931/720p.mp4</video:content_loc>
    <video:duration>624</video:duration>
    <video:publication_date>2023-12-15T19:44:28.902Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/test-driven-changes/state_and_strategy_design_pattern</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891440443/poster.jpg</video:thumbnail_loc>
    <video:title>State and Strategy Design Pattern</video:title>
    <video:description>Tries the state and strategy design patterns to refactor the nested conditions of an AI engine&apos;s suggest move, and shows why the state approach hits a red flag.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891440443/720p.mp4</video:content_loc>
    <video:duration>402</video:duration>
    <video:publication_date>2023-12-15T19:44:45.260Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/test-driven-changes/writing_tests_for_timed_games</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891440688/poster.jpg</video:thumbnail_loc>
    <video:title>Writing Tests for Timed Games</video:title>
    <video:description>Creates a test around the game class and refactors the confusing timed move logic by extracting variables, inlining a method and comparing if statements with a ternary.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891440688/720p.mp4</video:content_loc>
    <video:duration>305</video:duration>
    <video:publication_date>2023-12-15T19:45:02.828Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/test-driven-changes/factory_design_pattern</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/891440845/poster.jpg</video:thumbnail_loc>
    <video:title>Factory Design Pattern</video:title>
    <video:description>Writes timer tests for a game, finds that building the game object needs many parameters, and moves the logic into a game creator factory.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/891440845/720p.mp4</video:content_loc>
    <video:duration>555</video:duration>
    <video:publication_date>2023-12-15T19:45:18.317Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/the-strategy-design-pattern/unit-tests-and-object-pools</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/903258535/poster.jpg</video:thumbnail_loc>
    <video:title>Unit Tests and Object Pools</video:title>
    <video:description>Moves game construction into a factory, passes timestamps into tests, and shares Cell objects through a static pool so they are not recreated again and again.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/903258535/720p.mp4</video:content_loc>
    <video:duration>513</video:duration>
    <video:publication_date>2024-01-16T11:25:49.865Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/the-strategy-design-pattern/setting-timed-test-cases</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/903258794/poster.jpg</video:thumbnail_loc>
    <video:title>Setting Timed Test Cases</video:title>
    <video:description>Sets up timed move tests for a tic tac toe game, debugs a failing timeout test and fixes moves being accepted after the game already had a winner.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/903258794/720p.mp4</video:content_loc>
    <video:duration>322</video:duration>
    <video:publication_date>2024-01-16T11:33:34.093Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/the-strategy-design-pattern/fixing-bugs-in-game-logic-and-factories</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/903258951/poster.jpg</video:thumbnail_loc>
    <video:title>Fixing bugs in Game Logic and Factories</video:title>
    <video:description>Writes more complex tests for the timed game and fixes the bugs they reveal in the move logic, the board copy, the winner check and the game factory.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/903258951/720p.mp4</video:content_loc>
    <video:duration>945</video:duration>
    <video:publication_date>2024-01-16T11:44:56.774Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/11-command-and-strategy-patterns/new-feature-email-notifications</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/919471681/poster.jpg</video:thumbnail_loc>
    <video:title>New Feature: Email Notifications</video:title>
    <video:description>Adds win and come-back email notifications to a game, then refactors the email service call into a command object with templates and a builder.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/919471681/720p.mp4</video:content_loc>
    <video:duration>782</video:duration>
    <video:publication_date>2024-03-09T11:08:18.911Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/11-command-and-strategy-patterns/inheritance-vs-composition-lld-chapter</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/920463237/poster.jpg</video:thumbnail_loc>
    <video:title>Inheritance vs. Composition</video:title>
    <video:description>Refactors email and SMS notification commands with a base class and builder, finds why it fails for specific command types, and weighs casting against composition.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/920463237/720p.mp4</video:content_loc>
    <video:duration>396</video:duration>
    <video:publication_date>2024-03-09T10:56:02.971Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/11-command-and-strategy-patterns/the-publisher-subscriber-model</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/921457700/poster.jpg</video:thumbnail_loc>
    <video:title>The Publisher Subscriber Model</video:title>
    <video:description>Refactors notification commands with composition, then introduces an event bus and subscribers so events are published without knowing who consumes them.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/921457700/720p.mp4</video:content_loc>
    <video:duration>981</video:duration>
    <video:publication_date>2024-03-09T10:49:37.694Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/low-level-design-payment-tracking-app-like-splitwise/problem_statement</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/559873634/poster.jpg</video:thumbnail_loc>
    <video:title>Problem Statement</video:title>
    <video:description>Problem statement for the Splitwise low level design: adding, editing and settling expenses, group expenses with simplified debts, comments and an activity log, and which features to implement.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/559873634/720p.mp4</video:content_loc>
    <video:duration>219</video:duration>
    <video:publication_date>2021-06-08T11:45:30.047Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/low-level-design-payment-tracking-app-like-splitwise/defining_objects_states_and_behaviors</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/559873141/poster.jpg</video:thumbnail_loc>
    <video:title>Defining objects states and behaviors</video:title>
    <video:description>Designs the Splitwise objects from state: expense, user, balance and group, shows how balances sum to zero, and compares summing in memory with a group by query.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/559873141/720p.mp4</video:content_loc>
    <video:duration>657</video:duration>
    <video:publication_date>2021-06-08T08:50:44.435Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/low-level-design-payment-tracking-app-like-splitwise/simplified_balances_algorithm</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/559873480/poster.jpg</video:thumbnail_loc>
    <video:title>Simplified Balances algorithm</video:title>
    <video:description>Minimizes the transactions needed to settle balances by repeatedly pairing the largest creditor and debtor using a heap, and shows an example where this is not optimal.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/559873480/720p.mp4</video:content_loc>
    <video:duration>335</video:duration>
    <video:publication_date>2021-06-08T08:51:37.462Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/low-level-design-payment-tracking-app-like-splitwise/apis_and_coding_requirements</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/559873918/poster.jpg</video:thumbnail_loc>
    <video:title>APIs and coding requirements</video:title>
    <video:description>Chooses the APIs to code in a Splitwise design, decides which to cache, and uses immutable objects so readers never see inconsistent balances.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/559873918/720p.mp4</video:content_loc>
    <video:duration>332</video:duration>
    <video:publication_date>2021-06-08T08:44:38.287Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/low-level-design-payment-tracking-app-like-splitwise/low_level_design</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/559874021/poster.jpg</video:thumbnail_loc>
    <video:title>Low Level Design</video:title>
    <video:description>Covers the architecture of a Splitwise style payment tracking app and the approach for an LLD interview: define objects, write the algorithm, then write tests.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/559874021/720p.mp4</video:content_loc>
    <video:duration>204</video:duration>
    <video:publication_date>2021-06-08T08:41:58.570Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/low-level-design-payment-tracking-app-like-splitwise/coding_building_the_service_skeleton_and_defining_objects</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/560815823/poster.jpg</video:thumbnail_loc>
    <video:title>Coding: Building the service skeleton and defining objects</video:title>
    <video:description>Starts coding the Splitwise design from the main algorithm: group and expense services, summing expenses into balance maps, and defining the model objects.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/560815823/720p.mp4</video:content_loc>
    <video:duration>622</video:duration>
    <video:publication_date>2021-06-11T14:23:52.518Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/low-level-design-payment-tracking-app-like-splitwise/coding_algorithm</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/559873761/poster.jpg</video:thumbnail_loc>
    <video:title>Coding: Algorithm</video:title>
    <video:description>Codes the payment graph algorithm for a Splitwise style app using two priority queues, matching the largest positive and negative balances until all are settled.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/559873761/720p.mp4</video:content_loc>
    <video:duration>249</video:duration>
    <video:publication_date>2021-06-08T10:20:35.574Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/low-level-design-payment-tracking-app-like-splitwise/coding_test_cases</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/559874123/poster.jpg</video:thumbnail_loc>
    <video:title>Coding: Test cases</video:title>
    <video:description>Tests the Splitwise group service by reusing the whiteboard example, finds a bug in the add amount method, and checks the payment graph with an add expense method.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/559874123/720p.mp4</video:content_loc>
    <video:duration>365</video:duration>
    <video:publication_date>2021-06-08T08:35:55.227Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/low-level-design-payment-tracking-app-like-splitwise/conclusion_and__tips</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/559874316/poster.jpg</video:thumbnail_loc>
    <video:title>Conclusion and  Tips</video:title>
    <video:description>Recaps the payment tracking app design and gives three interview tips: clarify requirements, attack the main problem first, and prepare your coding environment.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/559874316/720p.mp4</video:content_loc>
    <video:duration>182</video:duration>
    <video:publication_date>2021-06-08T08:19:19.147Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-cache/1_caching_engineering_requirements</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/558968127/poster.jpg</video:thumbnail_loc>
    <video:title>#1: Caching: Engineering requirements</video:title>
    <video:description>The first lesson on machine coding a cache sets its requirements: reads, updates and evictions, the trade-off between write-back and write-through policies, and a read-your-own-writes guarantee.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/558968127/720p.mp4</video:content_loc>
    <video:duration>324</video:duration>
    <video:publication_date>2021-06-07T12:07:32.884Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-cache/2-read-your-own-writes</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/558971668/poster.jpg</video:thumbnail_loc>
    <video:title>#2: Read your writes</video:title>
    <video:description>Explains the read your own writes guarantee in a cache with a write then read example, and shows why a later read must wait for the write to finish.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/558971668/720p.mp4</video:content_loc>
    <video:duration>254</video:duration>
    <video:publication_date>2021-06-07T12:08:03.796Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-cache/3_defining_the_core_requirements</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/558972004/poster.jpg</video:thumbnail_loc>
    <video:title>#3: Defining the core requirements</video:title>
    <video:description>Lists the eight core requirements of a cache, from read your own writes to hot loading and event logging, and explains what a machine coding round expects.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/558972004/720p.mp4</video:content_loc>
    <video:duration>132</video:duration>
    <video:publication_date>2021-06-07T12:08:43.521Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-cache/asynchronous_processing</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/558972182/poster.jpg</video:thumbnail_loc>
    <video:title>#4: Asynchronous processing: Keeping threads available</video:title>
    <video:description>Explains why a cache needs asynchronous results, covering a limited thread pool, blocked sockets and head of line blocking, and how Java futures solve it.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/558972182/720p.mp4</video:content_loc>
    <video:duration>316</video:duration>
    <video:publication_date>2021-06-07T12:09:14.546Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-cache/view_consistency</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/558973431/poster.jpg</video:thumbnail_loc>
    <video:title>#5: View Consistency through thread assignment</video:title>
    <video:description>Explains read your own writes as view consistency in a cache, compares locks with ordering, and shows how hashing a key to one thread keeps operations sequential.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/558973431/720p.mp4</video:content_loc>
    <video:duration>373</video:duration>
    <video:publication_date>2021-06-07T12:09:48.331Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-cache/code_skeleton</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/558988098/poster.jpg</video:thumbnail_loc>
    <video:title>Code #1: Code skeleton for &apos;Get&apos; and &apos;Set&apos;</video:title>
    <video:description>Writes the first version of a cache with get and set, using futures, a concurrent hash map and a data source, and compares write-through with write-back.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/558988098/720p.mp4</video:content_loc>
    <video:duration>1019</video:duration>
    <video:publication_date>2021-06-07T12:17:57.980Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-cache/code_2_setting_up_fast_evictions</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/559007053/poster.jpg</video:thumbnail_loc>
    <video:title>Code #2: Setting up fast evictions</video:title>
    <video:description>Codes cache expiry and eviction: an expiry queue keyed by load time, an immutable access details object, and a priority queue that orders by LRU or LFU.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/559007053/720p.mp4</video:content_loc>
    <video:duration>806</video:duration>
    <video:publication_date>2021-06-07T12:18:26.227Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-cache/thread_assignment_code</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/559007211/poster.jpg</video:thumbnail_loc>
    <video:title>Code #3: Thread Assignment and updating GET + SET</video:title>
    <video:description>Continues coding a cache by assigning each key to a single thread, updating get and set, and removing expired and low priority entries when the cache is full.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/559007211/720p.mp4</video:content_loc>
    <video:duration>779</video:duration>
    <video:publication_date>2021-06-07T15:03:03.291Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-cache/hot_loading_request_collapsing</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/559019162/poster.jpg</video:thumbnail_loc>
    <video:title>Code #4: Hot loading and Request Collapsing</video:title>
    <video:description>Codes the last cache requirements: hot loading of keys at start and request collapsing with futures so several requests for one key make a single database call.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/559019162/720p.mp4</video:content_loc>
    <video:duration>568</video:duration>
    <video:publication_date>2021-06-07T15:04:04.007Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-an-event-bus/what_is_an_event_bus</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/557482324/poster.jpg</video:thumbnail_loc>
    <video:title>What is an event bus?</video:title>
    <video:description>Introduces the event bus: events are objects that describe actions, publishers send them to a distributed bus, and subscribers such as an email service consume them.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/557482324/720p.mp4</video:content_loc>
    <video:duration>83</video:duration>
    <video:publication_date>2021-06-07T15:24:44.725Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-an-event-bus/breaking_down_engineering_requirements</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/557486882/poster.jpg</video:thumbnail_loc>
    <video:title>Breaking down engineering requirements</video:title>
    <video:description>Breaks down the engineering requirements of an event bus: event schema, topics, idempotency, dead letter queue, retries, no updates or deletes, reading modes and ordering.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/557486882/720p.mp4</video:content_loc>
    <video:duration>595</video:duration>
    <video:publication_date>2021-06-07T15:25:23.611Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-an-event-bus/the_mechanics_of_the_bus</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/557491908/poster.jpg</video:thumbnail_loc>
    <video:title>The mechanics of the bus</video:title>
    <video:description>Explains the mechanics of an event bus: reader threads chosen by hash of subscriber and topic, writer threads chosen by topic, and the ordering each guarantees.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/557491908/720p.mp4</video:content_loc>
    <video:duration>282</video:duration>
    <video:publication_date>2021-06-07T15:26:31.560Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-an-event-bus/why_use_threads</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/557502858/poster.jpg</video:thumbnail_loc>
    <video:title>Why use threads?</video:title>
    <video:description>Explains how threads give concurrency, why one thread keeps order but is slow, and how hashing user ids onto a thread pool gives causal ordering.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/557502858/720p.mp4</video:content_loc>
    <video:duration>254</video:duration>
    <video:publication_date>2021-06-07T15:27:20.086Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-an-event-bus/code_skeleton_algorithm</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/557520848/poster.jpg</video:thumbnail_loc>
    <video:title>Code Skeleton and using an extensible Retry Algorithm</video:title>
    <video:description>Starts the event bus code with topics mapped to events, then builds an abstract retry algorithm with exponential backoff and fixed interval subclasses.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/557520848/720p.mp4</video:content_loc>
    <video:duration>740</video:duration>
    <video:publication_date>2021-06-07T15:37:44.856Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-an-event-bus/the_keyed_executor</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/557523350/poster.jpg</video:thumbnail_loc>
    <video:title>The Keyed Executor</video:title>
    <video:description>Writes the event bus publish method and a keyed executor, a fixed thread pool that assigns tasks by key hash to keep ordering, then adds subscribe with a topic to subscribers map.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/557523350/720p.mp4</video:content_loc>
    <video:duration>373</video:duration>
    <video:publication_date>2021-06-07T15:38:32.270Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-an-event-bus/pull_and_push_subscribers</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/557521205/poster.jpg</video:thumbnail_loc>
    <video:title>Pull and Push Subscribers</video:title>
    <video:description>Defines push and pull subscribers for an event bus, refactors two identical maps into a subscription object and adds an event filter precondition.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/557521205/720p.mp4</video:content_loc>
    <video:duration>415</video:duration>
    <video:publication_date>2021-06-07T15:39:17.662Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-an-event-bus/data_structures_in_the_bus</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/557530831/poster.jpg</video:thumbnail_loc>
    <video:title>Defining the data structures in the bus</video:title>
    <video:description>Defines the data structures for the event bus: a nested map of subscriber indexes per topic and a concurrent skip list map that orders events by timestamp.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/557530831/720p.mp4</video:content_loc>
    <video:duration>240</video:duration>
    <video:publication_date>2021-06-07T15:40:04.288Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-an-event-bus/wrapper_classes</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/557542248/poster.jpg</video:thumbnail_loc>
    <video:title>Wrapper Classes</video:title>
    <video:description>Fixes event bus public API issues by adding an add-event method, hashing topic and subscriber for thread assignment, and wrapping IDs in classes.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/557542248/720p.mp4</video:content_loc>
    <video:duration>1186</video:duration>
    <video:publication_date>2021-06-07T15:40:46.074Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-an-event-bus/coding_the_tests</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/557542729/poster.jpg</video:thumbnail_loc>
    <video:title>Coding the tests</video:title>
    <video:description>Writes the first event bus test, hits null pointer exceptions, and fixes them with default values and by setting the subscriber index when a subscription is made.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/557542729/720p.mp4</video:content_loc>
    <video:duration>505</video:duration>
    <video:publication_date>2021-06-07T15:42:10.209Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-an-event-bus/conclusion</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/557552192/poster.jpg</video:thumbnail_loc>
    <video:title>Conclusion</video:title>
    <video:description>Wraps up the event bus chapter with its publisher and subscriber APIs, the maps that support them and the time complexity of each operation.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/557552192/720p.mp4</video:content_loc>
    <video:duration>756</video:duration>
    <video:publication_date>2021-06-07T15:43:06.862Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-rate-limiter/what-will-you-learn</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/808690712/poster.jpg</video:thumbnail_loc>
    <video:title>What will you learn</video:title>
    <video:description>Introduces the machine coding chapter on rate limiters: what a rate limiter is, its scope, options for handling rejected requests, and the back pressure, token bucket and timer wheel approaches.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/808690712/720p.mp4</video:content_loc>
    <video:duration>368</video:duration>
    <video:publication_date>2023-03-18T11:55:31.857Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-rate-limiter/rate-limiter-overview</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/808690294/poster.jpg</video:thumbnail_loc>
    <video:title>Rate Limiter Overview</video:title>
    <video:description>Sketches a rate limiter design with a distributed service, a configuration database, a cached rate limiting client in each service, and batched callbacks.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/808690294/720p.mp4</video:content_loc>
    <video:duration>410</video:duration>
    <video:publication_date>2023-03-18T12:45:05.361Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-rate-limiter/implementation-details</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/808689597/poster.jpg</video:thumbnail_loc>
    <video:title>Implementation Details</video:title>
    <video:description>Plans the rate limiter implementation on a class diagram: separating client and server, pluggable algorithms, accept and reject callbacks, futures and back pressure.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/808689597/720p.mp4</video:content_loc>
    <video:duration>619</video:duration>
    <video:publication_date>2023-03-18T12:39:26.051Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-rate-limiter/api-breakdown</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/808688928/poster.jpg</video:thumbnail_loc>
    <video:title>API Breakdown</video:title>
    <video:description>Breaks down the rate limiter design: service configuration by key, time unit and amount, client and server interaction, and the file structure of the project.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/808688928/720p.mp4</video:content_loc>
    <video:duration>573</video:duration>
    <video:publication_date>2023-03-18T12:37:36.733Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-rate-limiter/models-controllers-packages-and-threadpools</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/809304143/poster.jpg</video:thumbnail_loc>
    <video:title>Models, Controllers, Packages and ThreadPools</video:title>
    <video:description>Structures the rate limiter server into packages, defines the service configuration and update request models, and isolates thread pools in separate classes.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/809304143/720p.mp4</video:content_loc>
    <video:duration>720</video:duration>
    <video:publication_date>2023-03-18T11:28:38.786Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-rate-limiter/reading-and-writing-data</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/809303981/poster.jpg</video:thumbnail_loc>
    <video:title>Reading and Writing Data</video:title>
    <video:description>Structures the rate limiter project with a database connector, data access objects, controllers and an API gateway with a fixed thread pool so request reading is not blocked.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/809303981/720p.mp4</video:content_loc>
    <video:duration>946</video:duration>
    <video:publication_date>2023-03-18T12:58:24.328Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-rate-limiter/ratelimiter-client-setup</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/809303874/poster.jpg</video:thumbnail_loc>
    <video:title>RateLimiter Client Setup</video:title>
    <video:description>Builds the rate limiter client in a separate project, with an API class, models and requests, and accept and reject callbacks that run on a thread pool.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/809303874/720p.mp4</video:content_loc>
    <video:duration>683</video:duration>
    <video:publication_date>2023-03-18T11:20:26.716Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-rate-limiter/sliding-window-algorithm-setup</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/809303755/poster.jpg</video:thumbnail_loc>
    <video:title>Sliding Window Algorithm Setup</video:title>
    <video:description>Sets up the rate limiter algorithm package with an abstract algorithm, a default sliding window, a should accept method driven by timestamps, and the service config it needs.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/809303755/720p.mp4</video:content_loc>
    <video:duration>439</video:duration>
    <video:publication_date>2023-03-18T11:35:03.872Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-rate-limiter/dependency-inversion</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/809303668/poster.jpg</video:thumbnail_loc>
    <video:title>Dependency Inversion</video:title>
    <video:description>Looks at a sliding window that needs a service config fetched over an API, the problems with blocking calls and how to design the interface instead.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/809303668/720p.mp4</video:content_loc>
    <video:duration>509</video:duration>
    <video:publication_date>2023-03-18T11:40:43.856Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-rate-limiter/sliding-window-with-backpressure</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/809303594/poster.jpg</video:thumbnail_loc>
    <video:title>Sliding Window with Backpressure</video:title>
    <video:description>Covers thread responsibility for accept and reject callbacks, a sliding window with a threshold and back pressure, a time unit enum, and the flaw in forward pressure.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/809303594/720p.mp4</video:content_loc>
    <video:duration>606</video:duration>
    <video:publication_date>2023-03-18T12:13:30.437Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/machine-coding-a-rate-limiter/clearing-stale-entries-in-sliding-window</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/809303504/poster.jpg</video:thumbnail_loc>
    <video:title>Clearing Stale Entries in Sliding Window</video:title>
    <video:description>Completes the rate limiter&apos;s should accept method by removing expired timestamps from the sliding window, then recaps why the design has a client and a server.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/809303504/720p.mp4</video:content_loc>
    <video:duration>314</video:duration>
    <video:publication_date>2023-03-18T12:50:30.974Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/live-lld-classes/machine-coding-chess</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/758601639/poster.jpg</video:thumbnail_loc>
    <video:title>Machine Coding: Chess</video:title>
    <video:description>Class recording explaining what low level design rounds judge, then designing Chess with pieces, a board, valid moves, captures and check, followed by audience questions.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/758601639/720p.mp4</video:content_loc>
    <video:duration>5053</video:duration>
    <video:publication_date>2026-11-17T09:12:12.542Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/live-lld-classes/google-question-logger-part-1</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/758601842/poster.jpg</video:thumbnail_loc>
    <video:title>Google Question: Logger, Part 1</video:title>
    <video:description>Class recording solving a Google interview question: build a logger that prints logs in start order, comparing a linked list, map, TreeMap and a heap with a map.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/758601842/720p.mp4</video:content_loc>
    <video:duration>2775</video:duration>
    <video:publication_date>2026-11-17T09:12:12.542Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/live-lld-classes/logger-part-2-concurrency-and-locking</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/758601780/poster.jpg</video:thumbnail_loc>
    <video:title>Logger, Part 2: Concurrency and Locking</video:title>
    <video:description>Class recording continuing the logger design: blocking poll with futures, locking, a concurrent map and an executor service, and a test with 1000 tasks.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/758601780/720p.mp4</video:content_loc>
    <video:duration>4620</video:duration>
    <video:publication_date>2026-11-17T09:12:12.542Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/live-lld-classes/april-2023-orchestration-service-design</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/814275049/poster.jpg</video:thumbnail_loc>
    <video:title>April 2023: Orchestration Service Design</video:title>
    <video:description>Class recording that designs an orchestration service from a request with dependencies, covering validation, decoding, calling order and concurrency.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/814275049/720p.mp4</video:content_loc>
    <video:duration>3798</video:duration>
    <video:publication_date>2026-11-17T09:12:12.542Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/live-lld-classes/april-2023-calendar-event-scheduling</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/817851322/poster.jpg</video:thumbnail_loc>
    <video:title>April 2023: Calendar Event Scheduling</video:title>
    <video:description>Class recording on designing a calendar app, covering event booking, clashing client-generated IDs, many-to-many data, recurring events as blueprints and cron expressions.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/817851322/720p.mp4</video:content_loc>
    <video:duration>4496</video:duration>
    <video:publication_date>2026-11-17T09:12:12.542Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/live-lld-classes/may-2023-stock-trading-app-like-zerodha</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/822725870/poster.jpg</video:thumbnail_loc>
    <video:title>May 2023: Stock Trading App like Zerodha</video:title>
    <video:description>A class recording designing a stock trading app: requirements, users, orders, stocks and portfolio, services, notifications with the Observer pattern, then code.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/822725870/720p.mp4</video:content_loc>
    <video:duration>9586</video:duration>
    <video:publication_date>2026-11-17T09:12:12.542Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/live-lld-classes/june-2023-live-score-updates-polling-and-websockets</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/837627918/poster.jpg</video:thumbnail_loc>
    <video:title>June 2023: Live Score Updates, Polling and WebSockets</video:title>
    <video:description>Recorded live Q&amp;A class that designs live cricket score updates, comparing short polling, long polling and WebSockets and discussing connection limits.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/837627918/720p.mp4</video:content_loc>
    <video:duration>6364</video:duration>
    <video:publication_date>2026-11-17T09:12:12.542Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/live-lld-classes/july-2023-twitter-design-with-trending</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/841894807/poster.jpg</video:thumbnail_loc>
    <video:title>July 2023: Twitter Design with Trending</video:title>
    <video:description>A recorded mock interview designing Twitter: users, tweets, comments and reactions, a timeline with push and pull, a shared trending list and an abstract class.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/841894807/720p.mp4</video:content_loc>
    <video:duration>4913</video:duration>
    <video:publication_date>2026-11-17T09:12:12.542Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/live-lld-classes/oct-2023-pub-sub-message-queue-design</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/870351598/poster.jpg</video:thumbnail_loc>
    <video:title>Oct 2023: Pub/Sub Message Queue Design</video:title>
    <video:description>Class recording on designing a publish subscribe message queue at low level, covering topics, subscriber offsets, retries with a dead letter queue, push versus pull and back pressure.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/870351598/720p.mp4</video:content_loc>
    <video:duration>5263</video:duration>
    <video:publication_date>2026-11-17T09:12:12.542Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/live-lld-classes/nov-2023-coupon-rule-engine-for-food-delivery</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/888173883/poster.jpg</video:thumbnail_loc>
    <video:title>Nov 2023: Coupon Rule Engine for Food Delivery</video:title>
    <video:description>A class recording designing coupons for food delivery: validity checks, a single apply API, flexible rules from an admin dashboard, and indexing to pick candidates.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/888173883/720p.mp4</video:content_loc>
    <video:duration>5269</video:duration>
    <video:publication_date>2026-11-17T09:12:12.542Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/live-lld-classes/dec-2023-database-schema-design-and-git-storage</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/895198190/poster.jpg</video:thumbnail_loc>
    <video:title>Dec 2023: Database Schema Design and Git Storage</video:title>
    <video:description>A class recording that designs a database for a Git hosting product, covering access control lists, indexes, directories stored by hash and branches as root pointers.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/895198190/720p.mp4</video:content_loc>
    <video:duration>5293</video:duration>
    <video:publication_date>2026-11-17T09:12:12.542Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/supplementary-videos/design-tic-tac-toe-low-level-design-coding-interview</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/758600976/poster.jpg</video:thumbnail_loc>
    <video:title>Design Tic Tac Toe: Low Level Design Coding Interview</video:title>
    <video:description>Designs Tic-Tac-Toe as a low level design interview question: list the features, define the board, user and game objects, and make the win check constant time.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/758600976/720p.mp4</video:content_loc>
    <video:duration>934</video:duration>
    <video:publication_date>2026-11-17T09:12:12.542Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/low-level-design-course/supplementary-videos/low-level-design-interview-zomato-with-keerti-purswani</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1247546131/poster.jpg</video:thumbnail_loc>
    <video:title>Low Level Design Interview: Zomato with Keerti Purswani</video:title>
    <video:description>A recorded mock interview where a candidate designs order status and delivery executive assignment for Zomato, using the observer pattern, followed by feedback.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1247546131/720p.mp4</video:content_loc>
    <video:duration>2612</video:duration>
    <video:publication_date>2026-11-17T09:24:32.139Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/ai-engineering/who-is-this-course-for/course-intro</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1087367958/poster.jpg</video:thumbnail_loc>
    <video:title>Course Intro</video:title>
    <video:description>Course introduction covering the two main topics, large language models and vector databases, the intended audience of engineers and product leads, prerequisites, assignments and completion certificate.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1087367958/720p.mp4</video:content_loc>
    <video:duration>120</video:duration>
    <video:publication_date>2025-06-03T09:15:41.984Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/ai-engineering/what-are-vectors/how-are-vectors-constructed</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1086196429/poster.jpg</video:thumbnail_loc>
    <video:title>How are vectors constructed</video:title>
    <video:description>Explains how documents are plotted as points by their properties, why the number of dimensions is fixed (4,096 for Llama), how a neural network is trained to place similar objects close together, and when fine tuning the vectorisation is worth it.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1086196429/720p.mp4</video:content_loc>
    <video:duration>403</video:duration>
    <video:publication_date>2025-06-03T09:22:12.996Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/ai-engineering/what-are-vectors/choosing-the-right-db</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1087564797/poster.jpg</video:thumbnail_loc>
    <video:title>Choosing the right DB</video:title>
    <video:description>Explains why one dimensional indexes and ACID guarantees do not help with vector search, then weighs pgvector, a newer open source option and managed services such as Vertex AI and OpenSearch on fit, understanding and cost.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1087564797/720p.mp4</video:content_loc>
    <video:duration>206</video:duration>
    <video:publication_date>2025-06-03T09:23:50.611Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/ai-engineering/what-are-vectors/vector-compression</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1087564673/poster.jpg</video:thumbnail_loc>
    <video:title>Vector compression</video:title>
    <video:description>Explains why comparing a query with every document vector is too slow, then shows two fixes: compressing each dimension to two bits and clustering vectors around centroids, together known as quantisation.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1087564673/720p.mp4</video:content_loc>
    <video:duration>206</video:duration>
    <video:publication_date>2025-06-03T09:27:19.889Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/behavioural-interview-course/STAR-pattern/Why-is-STAR-used</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/768504640/poster.jpg</video:thumbnail_loc>
    <video:title>Why is STAR used?</video:title>
    <video:description>Explains why structured interviews such as the STAR technique are preferred over traditional interviews, and why competencies rather than IQ explain differences in job performance.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/768504640/720p.mp4</video:content_loc>
    <video:duration>164</video:duration>
    <video:publication_date>2022-11-08T14:34:43.380Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/behavioural-interview-course/STAR-pattern/What-is-the-STAR-pattern</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/768502693/poster.jpg</video:thumbnail_loc>
    <video:title>What is the STAR pattern</video:title>
    <video:description>Explains the STAR technique for behavioural interviews, covering what an interviewer wants to learn from the situation, task, action and result in a candidate&apos;s story.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/768502693/720p.mp4</video:content_loc>
    <video:duration>244</video:duration>
    <video:publication_date>2022-11-08T14:35:51.182Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/system-design-advanced/networks-deep-dive/breakdown-network-layers</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1234917243/poster.jpg</video:thumbnail_loc>
    <video:title>Breakdown: Network Layers</video:title>
    <video:description>Breaks a computer network into three layers, physical, routing and behavioural, using a mirror and a post box as examples, and maps them onto the OSI model.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1234917243/720p.mp4</video:content_loc>
    <video:duration>653</video:duration>
    <video:publication_date>2026-10-15T10:43:41.906Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/system-design-advanced/networks-deep-dive/internal_routing_mac_addresses_and_nat</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1234917253/poster.jpg</video:thumbnail_loc>
    <video:title>Internal routing: MAC addresses and NAT</video:title>
    <video:description>Explains why Google&apos;s pages are cached in content delivery networks around the world, then shows two ways a router returns a response to the right internal machine: network address translation and a MAC address table.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1234917253/720p.mp4</video:content_loc>
    <video:duration>413</video:duration>
    <video:publication_date>2026-10-15T10:43:41.906Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/system-design-advanced/networks-deep-dive/head_of_line_blocking</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1234917262/poster.jpg</video:thumbnail_loc>
    <video:title>Head of line blocking</video:title>
    <video:description>Explains head of line blocking with a queue of acknowledged messages, how HTTP 2.0 multiplexing splits messages into streams and frames, why a shared TCP connection still blocks, and how HTTP 3.0 (QUIC) over UDP removes the problem.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1234917262/720p.mp4</video:content_loc>
    <video:duration>316</video:duration>
    <video:publication_date>2026-10-15T10:43:41.906Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
<url>
  <loc>https://interviewready.io/learn/system-design-advanced/networks-deep-dive/video_transmission_web_rtc_and_http-dash</loc>
  <video:video>
    <video:thumbnail_loc>https://cdn.interviewready.io/lesson-videos/v1/1234917523/poster.jpg</video:thumbnail_loc>
    <video:title>Video transmission: WebRTC and HTTP-DASH</video:title>
    <video:description>Explains why video must be sent in packets, how HTTP-DASH and HLS adapt resolution to the client and its network over TCP, and how WebRTC over UDP lets browsers conference directly, with STUN, TURN and media servers mentioned.</video:description>
    <video:content_loc>https://cdn.interviewready.io/lesson-videos/v1/1234917523/720p.mp4</video:content_loc>
    <video:duration>609</video:duration>
    <video:publication_date>2026-10-15T10:43:41.906Z</video:publication_date>
    <video:family_friendly>yes</video:family_friendly>
  </video:video>
</url>
</urlset>
