# Data Structures Algorithms
All Data Structures Algorithms notes →1 — What is an Algorithm?
What separates an algorithm from a program — finiteness, definiteness, effectiveness — and why interviewers are grading the precision of your procedure, not just whether your code runs.
2 — Asymptotic Analysis
Why Big-O is really shorthand for Big-Theta, how worst/average/best case turns 'what's the complexity' into three different questions, and the feasibility ladder that tells you whether a brute-force idea will even finish running.
3 — Recursion
How recursion actually executes on the call stack, why Python has no tail-call optimization, when to convert recursion to iteration, and a worked factorial-digit-sum example.
4 — Mathematical Foundations
Combinatorics, modular arithmetic, GCD/LCM, and prime sieves — the discrete-math toolkit that counting, DP, and number-theory interview problems quietly depend on.
5 — Algorithm Design Principles
A field guide to recognizing which of the five recurring design paradigms — brute force, divide and conquer, greedy, dynamic programming, backtracking — a new problem is calling for, before you write a line of implementation.
# Prometheus
All Prometheus notes →2 — Time Series Fundamentals
The time series data model behind Prometheus — metric names, labels, timestamps, samples, and how PromQL classifies the data it operates on.
1 — Why Monitoring Exists
Evolution of monitoring, observability vs. monitoring, the USE/RED methods, the four golden signals, and SLIs/SLOs/SLAs as the vocabulary the rest of this book assumes.
# Observability
All Observability notes →1 — What Observability Actually Means
Observability vs. monitoring, the three-pillars critique, and why observability is a property of how a system was instrumented — not a tool you bought or a dashboard you built.
2 — The Signals
Metrics, logs, traces, profiles, and events — what each is built to capture, what it costs, and which question it actually answers vs. which one people mistakenly ask it.
3 — Telemetry Lifecycle
Traces a signal path from generation through collection, transport, storage, query, visualization, alerting, and retention.
4 — Observability Maturity Model
Maps the crawl/walk/run/autonomous stages of observability maturity to concrete platform and process capabilities.
# Aptitude
All Aptitude notes →Study & Practice Strategy
Spaced practice, error logging, and the speed-vs-accuracy tradeoff for aptitude prep.
Test Format & Scoring
Sectional cutoffs, negative marking math, and adaptive vs. fixed-form test formats.
What Aptitude Tests Actually Assess
Why aptitude rounds still gate MAANG-adjacent hiring pipelines even when the core interview loop is DSA and system design.
# Ci Cd
All Ci Cd notes →1 — Git as the Platform Backbone
Covers how branching strategy, trunk-based development vs GitFlow, and monorepo vs polyrepo choices shape everything a CI/CD platform has to support.
2 — Pipeline Architecture
Compares pipeline-as-code, declarative pipeline models, event-driven triggering, and workflow orchestration as the architectural building blocks of any pipeline system.
3 — Pipeline Design Principles
Establishes idempotency, reusability, modularity, parameterization, and composability as the design principles that separate a maintainable pipeline from a fragile one.
4 — Pipeline Lifecycle
Walks the full pipeline lifecycle — trigger, build, test, package, deploy, verify, promote, rollback — as the canonical stage model referenced throughout the book.
5 — GitHub Actions: CI/CD Design Patterns
Covers build-once-deploy-many, immutable artifacts, promotion pipelines, GitOps, and trunk-based development as durable CI/CD design patterns.
# Data Engineering
All Data Engineering notes →1 — What is Data Engineering?
How data engineering evolved into its own discipline, how the role differs from analytics engineering and data science, and the foundational distinctions (batch vs. streaming, OLTP vs. OLAP) that shape the rest of this book.
2 — Data Lifecycle
The end-to-end journey data takes from generation through collection, ingestion, storage, processing, serving, consumption, governance, and eventual archival.
3 — Data Engineering Principles
The cross-cutting engineering principles — scalability, reliability, maintainability, data quality, idempotency, fault tolerance, cost, security, and observability — that every pipeline in this book is judged against.
# Dbms
All Dbms notes →1 — Why Databases Exist
Traces the shift from file-based storage to DBMS, the problems that shift solved, and introduces OLTP vs OLAP and the CAP perspective.
2 — Database Architecture
Covers the three-schema architecture (external, conceptual, internal), data independence, and the core components inside a DBMS.
3 — Database Models
Surveys the hierarchical, network, relational, object-oriented, object-relational, and NoSQL data models and how each represents data.
# Kubernetes
All Kubernetes notes →1 — Why Kubernetes Exists
Why declarative, self-healing reconciliation beat hand-rolled scripts and imperative config management once server fleets outgrew what humans could reconcile by hand.
2 — Linux Fundamentals
Why a container is just a regular Linux process wearing namespaces for isolation and cgroups for resource limits, not a lightweight virtual machine.
3 — Containers & OCI
Why the OCI image and runtime specs matter more than Docker itself — they let containerd, CRI-O, and Podman run the same artifact without vendor lock-in.
4 — Kubernetes Architecture
Why the control plane's continuous reconciliation loop, not the scheduler alone, is what makes Kubernetes self-healing rather than merely self-installing.
5 — Installing Kubernetes
Why kubeadm, managed control planes, and kubeadm-free distros mainly differ in who owns lifecycle and upgrade risk, not in what a conformant cluster actually runs.
6 — Kubernetes API & Object Model
Why kubectl is just a REST client — every object is a resource in the API server's store, making the API server the only legitimate path to change cluster state.
# Object Oriented Programming
All Object Oriented Programming notes →1 — Evolution of Programming Paradigms
Surveys Machine Programming, Procedural Programming, Structured Programming, Modular Programming, Object-Oriented Programming, Functional Programming, Event-Driven Programming, Reactive Programming, and Comparing Programming Paradigms as the core sub-topics of evolution of programming paradigms.
2 — Why OOP Exists
Surveys Software Complexity, Code Reusability, Maintainability, Real-world Modeling, Separation of Concerns, and Abstraction vs Implementation as the core sub-topics of why oop exists.
3 — Objects and Classes
Surveys Objects, Classes, State, Behavior, Identity, Object Lifetime, and Object Relationships as the core sub-topics of objects and classes.
# Operating System
All Operating System notes →1 — What is an Operating System?
Covers the evolution of operating systems, the goals of an OS, types of operating systems, kernel vs. user space, monolithic vs. microkernel vs. hybrid kernels, system calls, and the boot process overview.
2 — Computer Architecture Essentials
Covers CPU architecture, registers, the memory hierarchy, caches, interrupts, DMA, timers, device controllers, and NUMA basics — the hardware substrate an OS manages.
3 — OS Interfaces
Covers ABI vs. API, POSIX, the shell, the CLI, libraries, executables, the ELF format, and dynamic linking.
# Sre
All Sre notes →1 — What is Site Reliability Engineering?
What SRE actually is when you strip away the Google mythology — applying software engineering discipline to operations problems, with error budgets as the mechanism that makes reliability a measurable, negotiable trade-off instead of an absolute.
2 — History of SRE (Google and Beyond)
How Ben Treynor's 2003 Google team turned an operations headcount problem into a discipline, and how the practice diverged as Amazon, Microsoft, Meta, and Netflix each adapted it to their own org shape.
3 — DevOps vs SRE vs Platform Engineering
Three overlapping answers to the same organizational question — who owns production — and where each discipline's boundary actually sits when a service crosses it.
4 — Reliability as an Engineering Discipline
Why reliability has to be designed and budgeted like a feature, not bolted on afterward as an operations concern.
5 — Service Lifecycle
The stages a service moves through from design to deprecation, and the reliability gate that should exist at every transition.
6 — Production Readiness Reviews
The structured checklist that turns 'is this ready for production' from a gut call into a repeatable, auditable gate before a service takes real traffic.
7 — Reliability Engineering Mindset
The shift from reactive firefighting to designing for known failure modes — probabilistic thinking about what will break, not just how to react when it does.
8 — Shared Ownership Model
Why 'you build it, you run it' only works with a real ownership contract behind it — the engagement model, escalation path, and toil ceiling that keep shared ownership from silently becoming SRE-owns-everything.
9 — Cost, Reliability and Velocity Trade-offs
The three-way trade-off underneath almost every reliability decision, and why optimizing any one of cost, reliability, or shipping velocity in isolation breaks the other two.