• Backend: Python (Django, FastAPI,tooling:ruff,uv), Rust (actix-web, axum)
• Frontend: Svelte / SvelteKit
• Tools: Linux, Git, Docker
• Patterns & Principles: SOLID, DRY, YAGNI, KISS, naming, architecture, extendibility

• Arrays, Linked Lists, Trees, Graphs
• Sorting, Searching
• Hash Maps, Sets
• Recursion, Dynamic Programming (DP)
• Time & Space Complexity (Big O)

Tip: Revise once per year — but don’t overstress memorization. Deep pattern recognition is more important.

• SOLID (OOP principles)
• DRY (Don’t Repeat Yourself)
• KISS (Keep It Simple, Stupid)
• YAGNI (You Ain’t Gonna Need It)

• Sliding Window
  For subarrays/substrings with optimal time (e.g., max sum, longest substring).

  • Example: Maximum Subarray, Longest Substring Without Repeating Characters

• Two Pointers
  For problems on sorted arrays/linked lists (e.g., pair sum, reverse).

  • Example: Two Sum II, Remove Duplicates from Sorted Array

• Fast & Slow Pointers (Cycle Detection)
  Detect cycles or find middle in linked lists.

  • Example: Linked List Cycle, Find Middle of Linked List

• Merge Intervals
  For interval overlap/merge problems.

  • Example: Merge Intervals, Insert Interval

• Binary Search
  For sorted arrays/search space reduction.

  • Example: Search in Rotated Sorted Array, Find Minimum in Rotated Sorted Array

• Backtracking
  For permutations, combinations, and subsets.

  • Example: Subsets, Permutations, Combination Sum

• Breadth-First Search (BFS)
  For shortest path in unweighted graphs/trees.

  • Example: Binary Tree Level Order Traversal, Word Ladder

• Depth-First Search (DFS)
  For traversals, connected components, and recursion.

  • Example: Number of Islands, Clone Graph

• Dynamic Programming (DP)
  For optimal substructure/overlapping subproblems.

  • Example: Climbing Stairs, House Robber, Longest Increasing Subsequence

• Greedy
  For local optimal → global optimal.

  • Example: Jump Game, Gas Station

• Heap/Priority Queue
  For top K elements, merging sorted lists.

  • Example: Kth Largest Element, Merge K Sorted Lists

• Trie
  For prefix-based search.

  • Example: Implement Trie, Word Search II

Tip:
Focus on understanding the pattern, not just the solution.
LeetCode Patterns Reference

• MVC (Model-View-Controller)
  Separates application logic into three interconnected components.

  graph TD
  Model --> Controller
  Controller --> View
  View --> Model

• MVVM (Model-View-ViewModel)
  Enhances MVC with two-way binding between view and view model.

  graph TD
  Model --> ViewModel
  ViewModel --> View
  View --> ViewModel

• Layered Architecture
  Organizes code into layers with specific responsibilities.

  graph TD
  UI --> Application
  Application --> Domain
  Domain --> Infrastructure

• Client-Server
  Divide systems into a server (provider) and client (consumer).

  graph TD
  Client -->|Request| Server
  Server -->|Response| Client

• Microservices
  Decompose a system into small, independently deployable services.

  graph TD
  ServiceA --> API
  ServiceB --> API
  ServiceC --> API
  API --> Client

Description:
Class diagrams represent the structure of classes in a system, showing their attributes, methods, and relationships.

classDiagram  
    class Animal {  
        +String name  
        +int age  
        +makeSound()  
    }  

    class Dog {  
        +String breed  
        +bark()  
    }  

    class Cat {  
        +scratch()  
    }  

    Animal <|-- Dog  
    Animal <|-- Cat  

Description:
Use case diagrams visualize the interactions between users (actors) and the system to achieve goals (use cases).

graph TD  
    Actor((👤 User)) -->|Uses| System[🖥️ System]  
    System --> UC1(📌 Use Case 1)  
    System --> UC2(📌 Use Case 2)  
    UC1 -.-> UC2  

Description:
Sequence diagrams show how objects or components interact in a particular sequence of time-ordered messages.

sequenceDiagram  
    participant User as 👤 User  
    participant WebApp as 🌐 WebApp  
    participant Server as 🖥️ Server  

    User->>WebApp: Request Page  
    WebApp->>Server: Fetch Data  
    Server-->>WebApp: Return Data  
    WebApp-->>User: Render Page  

Description:
Activity diagrams model the flow of control or data between activities, useful for describing workflows and logic.

flowchart TD  
    Start([🚀 Start]) --> A[🔐 Login]  
    A --> B{✅ Valid?}  
    B -- Yes --> C[📊 Show Dashboard]  
    B -- No --> D[❌ Show Error]  
    C --> End([🏁 End])  
    D --> End  

Description:
State diagrams represent the possible states of an object and transitions triggered by events or actions.

stateDiagram-v2  
    [*] --> Idle  
    Idle --> Processing : ▶️ start()  
    Processing --> Finished : ✔️ complete()  
    Finished --> [*]  

Description:
Component diagrams model the components of a system and how they interact through interfaces.

graph TB  
    Client["🧑‍💻 Client"] -->|uses| API["🌐 API"]  
    API --> Controller["🧭 Controller"]  
    Controller --> Service["⚙️ Service"]  
    Service --> Database["(🗄️ Database)"]  

Description:
Deployment diagrams show the physical layout of hardware and how software components are deployed on them.

graph TD  
    subgraph "🧑‍💻 Client Node" 
        Browser["🌍 Browser"]  
    end  

    subgraph "🖥️ Server Node"  
        WebApp["🧠 WebApp"]  
        DB["(🗃️ Database)"]  
    end  

    Browser --> WebApp  
    WebApp --> DB  

Description:
Object diagrams depict instances of classes (objects) and their relationships at a specific point in time.

classDiagram  
    class Person {  
        +String name  
        +int age  
    }  

    Person : name = "Alice"  
    Person : age = 30  

• Layered Architecture (Controllers → Services → Repos)
• Hexagonal Architecture (Ports & Adapters, decouple domain)
• CQRS (Command Query Responsibility Segregation)
• Event-Driven Architecture (pub/sub systems, message queues)

• Entities → objects with identity (e.g., User, Order)
• Value Objects → immutable, no ID (Money, Coordinates)
• Aggregates → groups of entities with a root
• Ubiquitous Language → name code after domain terms

• Finite State Machines → use XState or implement manually
• Statecharts → for complex UIs (multi-step flows)
• Reactive Patterns → data flow graphs, not just stores

• Given-When-Then (BDD style)
• Test Doubles (Mock, Stub, Fake)
• Property-Based Testing (e.g., hypothesis in Python, proptest in Rust)

• Rebase, squash commits
• Feature branch workflows
• Writing meaningful commit messages
• Handling merge conflicts like a pro

• Writing multi-stage Dockerfiles
• Using docker-compose for dev envs
• Building minimal, production-ready images
• Understanding networks, volumes, healthchecks

• Bash scripting
• grep, awk, sed for text processing
• Managing services with systemd
• Networking basics (netstat, curl, dig)

• Github Actions / Gitlab CI pipelines
• Lint → Test → Build → Deploy sequences
• Using Docker in CI pipelines

• Consistent → predictable patterns everywhere
• Simple → easy for clients to understand & use
• Versioned → changes don't break old clients
• Secure → protects against common vulnerabilities
• Extensible → easy to add features without breaking old ones
• Well-documented → clear and accurate API docs

Books:

• Clean Code by Robert C. Martin
• Clean Architecture by Robert C. Martin
• Domain-Driven Design Distilled by Vaughn Vernon
• Patterns of Enterprise Application Architecture by Martin Fowler
• Refactoring UI by Adam Wathan

Videos & Playlists:

Mastermind devs don’t memorize patterns — they name their instincts and record decisions.
Trust your intuition. Level it up by learning the names.
Then, you'll not only code well — you'll design systems that last 🔥.