Beginner on Dev & Platform Engineering Hub

Kubernetes Ep 4: Deployments, ReplicaSets & Self-Healing Scaling

Mon, 10 Aug 2026 00:20:00 +0000

While Pods are the basic building blocks of Kubernetes, you should rarely deploy bare Pods directly. Instead, production applications use Deployments, a higher-level abstraction that manages ReplicaSets to guarantee high availability, self-healing, and seamless scaling.

Kubernetes Ep 3: kubectl CLI & Launching Your First Pod

Mon, 10 Aug 2026 00:15:00 +0000

The kubectl command-line interface is the primary tool platform engineers and developers use to interact with Kubernetes clusters. In this episode, we’ll configure kubectl and deploy our first atomic Kubernetes primitive: the Pod.

Kubernetes Ep 2: Architecture - Control Plane & Worker Nodes

Mon, 10 Aug 2026 00:10:00 +0000

A Kubernetes cluster consists of two primary logical layers: the Control Plane (the cluster’s brain) and Worker Nodes (the muscle that runs application containers). Understanding how these components communicate is crucial for cluster administration and troubleshooting.

Kubernetes Ep 1: Introduction to Kubernetes & Containers

Mon, 10 Aug 2026 00:05:00 +0000

The evolution of modern infrastructure has transitioned from physical bare-metal servers to Virtual Machines (VMs), lightweight OCI Containers, and ultimately automated Container Orchestration platforms like Kubernetes.

Kratix Ep 8: Developer Self-Service Workflow

Sun, 09 Aug 2026 21:20:00 +0000

We have spent 7 episodes architecting a massively scalable, secure backend. But if the Developer Experience (DX) is terrible, no one will use it. In this episode, we switch personas to the Application Developer and explore the day-to-day workflow of consuming a Kratix Platform.

Kratix Ep 3: Kratix GitOps vs Crossplane GitOps

Sun, 09 Aug 2026 20:30:00 +0000

Crossplane uses GitOps to provision AWS infrastructure. Kratix uses GitOps to orchestrate Promises. This frequently leads to severe architectural confusion for teams adopting Platform Engineering. In this episode, we define the exact boundary between the two tools and learn how they complement each other in a Production IDP.

Kratix Ep 2: Multi-Cluster Architecture & IaC

Sun, 09 Aug 2026 20:20:00 +0000

In this episode, we deeply analyze the ‘Where’ of the 5W1H framework. We will map out the Hub and Spoke topology, learn why Kratix intentionally isolates the Platform Cluster from the Worker Clusters for security, and explore how traditional Infrastructure-as-Code (like Terraform) executes inside this GitOps-driven model.

Crossplane Ep 5: Compositions

Sun, 09 Aug 2026 17:50:00 +0000

In Episode 4, we built an API (XRD) but it didn’t actually create any AWS infrastructure. In this final fundamental episode, we write a Composition. This is the ’translation engine’ that instructs Crossplane exactly which physical Managed Resources to create when a developer requests our custom API.

Crossplane Ep 4: Composite Resources (XR)

Sun, 09 Aug 2026 17:40:00 +0000

Managed Resources (MRs) are too low-level for application developers. In this episode, we learn how to define a Composite Resource Definition (XRD). This allows Platform Engineers to design a brand new, highly abstracted Custom Kubernetes API tailored exactly to their company’s needs.

Crossplane Ep 3: Managed Resources (MR)

Sun, 09 Aug 2026 17:30:00 +0000

A Managed Resource (MR) is the foundational building block of Crossplane. It is a 1-to-1 representation of a physical cloud object (like an S3 Bucket or an RDS Instance) stored as a Custom Resource in Kubernetes. In this episode, we provision our first AWS resource directly via kubectl.

Crossplane Ep 2: Providers and Credentials

Sun, 09 Aug 2026 17:20:00 +0000

Crossplane is useless on its own. To orchestrate AWS, Azure, or GCP, we must install Providers. In this episode, we install the official Upbound AWS Provider, configure Kubernetes Secrets to store our IAM credentials, and bind them to a ProviderConfig.

Crossplane Ep 1: The Kubernetes Native Control Plane

Sun, 09 Aug 2026 17:10:00 +0000

To understand Crossplane, you must first understand the Kubernetes Control Loop. In this episode, we explore the theoretical difference between CLI-driven IaC (Terraform) and Control Plane IaC (Crossplane). We will then install Crossplane into a local cluster using Helm.

Pulumi Ep 5: Inputs, Outputs, and Promises (The Asynchronous Conundrum)

Sun, 09 Aug 2026 14:50:00 +0000

When you write standard TypeScript, data is computed immediately. But in Pulumi, when you request an EC2 instance’s IP address, the IP does not exist until AWS physically boots the server. This introduces temporal paradoxes. In this final fundamental episode, we master Inputs, Outputs, and how to safely manipulate asynchronous infrastructure data.

Pulumi Ep 4: Configuration and Secrets Management

Sun, 09 Aug 2026 14:40:00 +0000

Hardcoding values like instance sizes and database passwords into your TypeScript code is a severe anti-pattern. In this episode, we learn how to decouple configuration from code using the Pulumi Config system, allowing the exact same codebase to deploy vastly different Staging and Production architectures.

Pulumi Ep 3: Declaring Resources in TypeScript

Sun, 09 Aug 2026 14:30:00 +0000

In Terraform, you write declarative configuration blocks. In Pulumi, you instantiate Object-Oriented classes. This episode explores how to declare complex resources like an AWS VPC, Security Group, and EC2 instance using pure TypeScript, while leveraging your IDE’s IntelliSense for maximum productivity.

Pulumi Ep 2: Stacks and State Management

Sun, 09 Aug 2026 14:20:00 +0000

Managing state files in Terraform is notoriously difficult, requiring external buckets and DynamoDB locks. Pulumi solves this out-of-the-box using the Pulumi Service. In this episode, we explore how State is managed, and how to use Stacks to deploy identical infrastructure to Staging and Production environments safely.

Pulumi Ep 1: Introduction to Pulumi and Project Initialization

Sun, 09 Aug 2026 14:10:00 +0000

It is time to leave YAML behind. In this episode, we will install the Pulumi CLI, scaffold a brand new TypeScript project, and understand the anatomy of the generated files. You will learn how Pulumi securely integrates with your cloud provider credentials.

KCNA Ep 5: Cloud Native Security & GitOps Practices

Sun, 09 Aug 2026 13:25:00 +0000

Modern cloud-native operations rely on declarative security governance (RBAC, Network Policies) and automated continuous delivery (GitOps). In this final KCNA episode, we cover security fundamentals, GitOps workflows, and Service Meshes.

KCNA Ep 4: Telemetry, Observability & Monitoring

Sun, 09 Aug 2026 13:20:00 +0000

Observability allows engineers to infer the internal state of a complex distributed system based on its external outputs. For the KCNA exam, you must understand the Three Pillars of Observability and the CNCF tools that collect them.

KCNA Ep 3: Container Orchestration & Workload Primitives

Sun, 09 Aug 2026 13:15:00 +0000

Workload resources define how application containers are scheduled, scaled, and managed across a Kubernetes cluster. Understanding when to choose a Deployment vs a StatefulSet, DaemonSet, or Job is essential for the KCNA exam.

KCNA Ep 2: Kubernetes Fundamentals & Architecture

Sun, 09 Aug 2026 13:10:00 +0000

A Kubernetes cluster is divided into a Control Plane (the brain) and Worker Nodes (the muscle). Understanding how these components communicate via the declarative REST API is a core requirement for the KCNA exam.

KCNA Ep 1: CNCF Ecosystem & Cloud Native Architecture

Sun, 09 Aug 2026 13:05:00 +0000

The Kubernetes and Cloud Native Associate (KCNA) exam is a multiple-choice certification designed to test your foundational knowledge of the cloud-native ecosystem. In this first episode, we explore the CNCF landscape, cloud-native architecture patterns, and containerization principles.

TS Ep 1: Fundamental TypeScript — Inference, Type Narrowing, and Discriminated Unions

Sun, 09 Aug 2026 12:30:00 +0000

The foundational guide to mastering TypeScript. Learn how the type inference engine works, master type narrowing with typeof, instanceof, in, and custom type predicates (is), build type-safe discriminated unions, and use as const assertions.

TS Ep 15: Immutability with `as const` & Const Assertions

Sun, 09 Aug 2026 11:10:00 +0000

An exhaustive analysis of Const Assertions (as const). Learn the 3 transformation rules of const assertions, deep recursive read-only object properties, converting arrays into readonly tuples, and deriving union types dynamically using typeof ARRAY[number].

TS Ep 14: The Never Type & Exhaustive Checks

Sun, 09 Aug 2026 11:05:00 +0000

An exhaustive deep dive into TypeScript’s bottom type (never). Learn how set theory models the empty set ($mptyset$), the 3 sources of ’never’ in type analysis, and how to implement compile-time exhaustiveness checking for Discriminated Unions.

TS Ep 13: Function Overloads — Polymorphic Signatures

Sun, 09 Aug 2026 11:00:00 +0000

An in-depth guide to Function Overloads in TypeScript. Learn how to define multiple overload signatures, why the implementation signature is invisible to callers, how TypeScript matches overloads sequentially, and when to use Union types instead of Overloads.

TS Ep 12: Function Typing, Call Signatures, and Void Semantics

Sun, 09 Aug 2026 10:55:00 +0000

An exhaustive guide to typing functions in TypeScript. Learn function expressions, type aliases, destructuring parameter signatures, optional/default/rest parameters, call signatures with properties, and why ‘void’ callbacks ignore return values.

TS Ep 11: Discriminated Unions — Tagged Unions & Domain Modeling

Sun, 09 Aug 2026 10:50:00 +0000

An exhaustive guide to Discriminated Unions in TypeScript. Learn why optional property blobs create impossible states, the 3 requirements for tagged unions, how Control Flow Analysis narrows discriminants, and real-world domain state patterns.

TS Ep 10: Custom Type Guards & Assertion Functions

Sun, 09 Aug 2026 10:45:00 +0000

Learn how to build custom runtime type validators in TypeScript. Master Type Predicates (parameter is Type), Assertion Functions (asserts val is Type), array .filter() type narrowing, and safely parsing untrusted external JSON data.

TS Ep 9: Type Narrowing & Control Flow Analysis

Sun, 09 Aug 2026 10:40:00 +0000

Understand how TypeScript’s Control Flow Analysis engine refines types across code branches. Master typeof guards (and the typeof null quirk), instanceof class narrowing, the ‘in’ property operator, equality narrowing, and truthiness pitfalls.

TS Ep 8: Literal Types — Unit Types & Enum Alternatives

Sun, 09 Aug 2026 10:35:00 +0000

An in-depth breakdown of TypeScript Literal Types. Understand unit types in set theory, how string/number literal unions replace Enums with zero runtime overhead, and how to solve object property literal widening bugs.

TS Ep 7: Union and Intersection Types — Set Theory Mechanics

Sun, 09 Aug 2026 10:30:00 +0000

An in-depth analysis of Unions and Intersections in TypeScript. Understand how set theory models type relationships ($A \cup B$ vs $A \cap B$), property access rules, property conflict resolution to ’never’, and operator precedence.

TS Ep 6: Any vs. Unknown — Top Types and Type Safety

Sun, 09 Aug 2026 10:25:00 +0000

Understand the type-system mechanics of top types in TypeScript. Learn why ‘any’ disables type checking and causes type contagion, why ‘unknown’ provides safe dynamic typing, and how to use ‘unknown’ with runtime validation.

TS Ep 5: Arrays, Tuples, and Readonly Collections

Sun, 09 Aug 2026 10:20:00 +0000

An exhaustive guide to typing collections in TypeScript. Learn the syntax differences between T[] and Array, union array typing precedence, labeled tuple elements, rest tuples, and why readonly arrays prevent array mutation bugs.

TS Ep 4: Object Types, Interfaces, and Structural Typing

Sun, 09 Aug 2026 10:15:00 +0000

Learn how to model object shapes in TypeScript. We cover inline types, type aliases, interfaces, optional properties vs undefined, readonly modifiers, index signatures, and TypeScript’s structural type system.

TS Ep 3: Type Annotations vs. Type Inference

Sun, 09 Aug 2026 10:10:00 +0000

Stop writing redundant type annotations. Learn how TypeScript infers types, the mechanics of literal type widening (let vs const), contextual typing in callbacks, and the precise rules for when explicit type annotations are required.

TS Ep 2: Primitive Types — Deep Dive into JS Primitives

Sun, 09 Aug 2026 10:05:00 +0000

An exhaustive breakdown of TypeScript’s 7 primitive types. Learn how TS handles floating-point numbers, BigInts, symbols, strictNullChecks, and the critical structural differences between lowercase primitive types and uppercase Object wrappers.

TS Ep 1: Introduction, Compilation, and Compiler Setup

Sun, 09 Aug 2026 10:00:00 +0000

An in-depth introduction to TypeScript architecture. Understand static type checking vs runtime behavior, the internal stages of the TypeScript compiler (tsc), type erasure, and how to configure tsconfig.json with strict flags for professional development.

Terraform Ep 5: Querying Existing Cloud Infrastructure with Data Sources

Sun, 09 Aug 2026 09:50:00 +0000

Not everything in your cloud is managed by Terraform. In this episode, you will learn how to use the ‘data’ block to interrogate the AWS API. Fetch the latest Ubuntu AMI ID dynamically, or retrieve a VPC ID created by the Networking team, ensuring your code remains hardcode-free.

Terraform Ep 4: Input Variables, Outputs, and Data Types

Sun, 09 Aug 2026 09:40:00 +0000

Hardcoding values in Terraform is a bad practice. In this episode, we will introduce Input Variables and Data Types to make your code reusable across multiple environments. You will also learn how to extract critical information using Outputs.

Terraform Ep 3: Declaring Resources and Dependency Management

Sun, 09 Aug 2026 09:30:00 +0000

It is time to build real infrastructure. In this episode, we will declare an AWS Virtual Private Cloud (VPC) and a Subnet. You will learn how Terraform intelligently determines the correct order of creation using the Dependency Graph, preventing race conditions.

Terraform Ep 2: Providers, Plugins, and Secure Authentication

Sun, 09 Aug 2026 09:20:00 +0000

Terraform itself cannot create an AWS EC2 instance. It relies on ‘Providers’ (plugins) to translate HCL code into cloud-specific API calls. In this episode, we connect Terraform to AWS and establish a secure, production-grade authentication mechanism.

Terraform Ep 1: Introduction to IaC and the State File

Sun, 09 Aug 2026 09:10:00 +0000

Stop deploying cloud resources manually. In this first episode, we will transform your approach to cloud architecture by introducing declarative IaC. You will learn how Terraform tracks physical resources using the state file, and execute your first local configuration.

Go Ep 6: Structs, Fields & JSON Serialization

Sun, 09 Aug 2026 08:45:00 +0000

Go is not a class-based object-oriented language. Instead, Go uses Structs to group typed fields together into contiguous memory blocks.

Go Ep 5: Maps & Hash Tables

Sun, 09 Aug 2026 08:40:00 +0000

Maps provide fast $O(1)$ key-value lookups. Understanding map initialization and comma-ok lookups is essential for safe data manipulation.

Go Ep 4: Arrays, Slices & Memory Capacity

Sun, 09 Aug 2026 08:30:00 +0000

In Go, an Array has a fixed length determined at compile time. A Slice is a lightweight, dynamically sized view into an underlying array. Understanding slice capacity (cap) prevents accidental memory reallocation overhead.

Go Ep 3: Functions, Defer & Closures

Sun, 09 Aug 2026 08:20:00 +0000

Functions in Go can return multiple values natively. Coupled with the defer statement, Go provides a clean, elegant mechanism for resource management that replaces cumbersome try/finally blocks.

Go Ep 2: Control Flow & Loops

Sun, 09 Aug 2026 08:10:00 +0000

Unlike languages with while, do-while, and foreach, Go has only ONE keyword for looping: for. This design eliminates syntax complexity while maintaining complete control over iteration.

K8s Ep 1: Architecture & Your First Multi-Node Local Cluster Setup

Sun, 09 Aug 2026 08:10:00 +0000

Many Kubernetes tutorials overwhelm you with hours of theory before ever touching a terminal. Here, we embrace the HowToForge philosophy: we build it first, then we dissect how it works.

Go Ep 1: Toolchain, Syntax & Primitive Types

Sun, 09 Aug 2026 08:00:00 +0000

Designed at Google by Robert Griesemer, Rob Pike, and Ken Thompson, Go (Golang) is an open-source programming language built for simplicity, concurrency, and high-performance systems engineering.