Justified Code/Systems Thinking

  • $129

Systems Thinking

  • Bundle
  • 5 Products

You will learn how to combine system design patterns to design systems that hold under reliability, cost, security and performance constraints.

You will see real systems analyzed end-to-end, from use case analysis and component decomposition to modernization and scalability.

You will understand how to defend architectural decisions under real constraints.

Save time and money.

Think like an Architect

The path I wish someone had laid out for me years ago.

Step 1 — Load your head with system design patterns

I keep learning this in system design: one pattern alone rarely gives you a full solution.

The solution is possible when you combine system design patterns across Reliability, Security, Cost, Performance, Data, and Operations.

Step 2 — See a real system end-to-end

Good architects design their diagrams based on the target audience. Business people never enjoy your technical diagrams. Developers admires who explain the why behind decisions.

Deep dive into:

  • uses cases analysis, and seeing the big picture

  • infrastructure and architecture

  • design by volatility (reasons of change)

  • component decomposition

This teaches how real systems are designed and explained.

Step 3 — Modernize a monolithic application

This document provides guidance for implementing modernization design patterns that let you add new features, and migrate existing ones without disrupting the business.

Step 4 — Complete the flight search system case study

This document analyzes how combining multiple architectural patterns solves this real world application problem effectively.

Step 5 — Make it survive growth

Scalability is the thing that separates good web applications from excellent ones. Watch me break down the 5 components of highly available web applications.

You’ll learn:

  • caching, queueing, data storage locks, and redundancy

  • why systems break under load

This teaches how designs hold under stress.

Contents

Complete Case Study — Flight Search System

  • Download
  • 1 file

Modern flight booking systems must integrate with multiple airline providers to offer search results. Each provider respond at different speeds and may fail independently. The challenge is building a system that can dispatch requests to all providers simultaneously, collect responses as they arrive, and present progressive results to users in real-time. This document solves this aggregation problem effectively.

Digital Bank Architecture

  • Course
  • 16 Lessons

Good architects design their diagrams based on the target audience. Business people never enjoy your technical diagrams. Developers admires who explain the why behind decisions. This course navigates a real digital banking solution. Starting with the use cases analysis diagram all the way to components diagrams, explaining the why behind each design and architecture decision.

Modernizing a Monolithic Application

  • Download
  • 1 file

Traditionally, monolithic applications run in a single process, use one data store, and run on servers that scale vertically. Modern services run across the network, use more than one data store, scale horizontally, and have independent fault domains. This guide provides guidance for implementing modernization design patterns that let you add new features, and migrate existing ones without disrupting the business.

System Design Patterns

  • Course
  • 36 Lessons

System design heavily relies on established design patterns. You can design distributed systems by using a combination of these patterns. These patterns are crucial for building reliable, secure, operationally efficient architectures that are optimized for cost and performance.

Web Applications Scalability

  • Course
  • 11 Lessons

This course includes lessons on the 5 components of highly scalable web applications. From caching and queueing to minimizing storage locks, handling asynchrony, and building redundancy, Scalability is the thing that separates good web applications from excellent ones. If you’re serious about building apps that don’t crumble under load, this is for you.