Intermediate on Dev & Platform Engineering Hub

Kubernetes Ep 11: Jobs, CronJobs & Batch Processing

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

Unlike Deployments and StatefulSets—which are designed to keep long-running processes alive indefinitely—Jobs and CronJobs are designed for run-to-completion batch tasks. When the workload process terminates with exit code 0, Kubernetes marks the Pod as Completed.

Kubernetes Ep 8: Persistent Volumes, PVCs & StorageClasses

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

Containers are designed to be stateless and ephemeral. To run stateful applications like PostgreSQL, MySQL, Redis, or Elasticsearch, Kubernetes provides storage abstractions that decouple persistent storage infrastructure from application workload definitions.

Kubernetes Ep 7: ConfigMaps, Secrets & Environment Variables

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

The Twelve-Factor App methodology mandates strict separation of application code from configuration settings. ConfigMaps store non-sensitive configuration data (URLs, log levels), while Secrets store sensitive values (passwords, API tokens, TLS keys).

Kubernetes Ep 6: Ingress Controllers & HTTP Path Routing

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

While L4 Kubernetes Services handle IP and port-level load balancing, modern web applications require Layer 7 HTTP/HTTPS routing features: URL path matching (/api vs /app), hostname routing (api.example.com), SSL/TLS termination, and header rewriting. This is handled by Ingress.

Kubernetes Ep 5: Networking Services (ClusterIP, NodePort, LoadBalancer)

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

Pods are ephemeral—they are created, destroyed, and rescheduled dynamically, causing their IP addresses to change constantly. A Kubernetes Service provides a stable, persistent virtual IP (VIP), DNS name, and load balancing frontend across a dynamic set of backend Pods.

Kratix Ep 10: Observability and Operations

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

Operating a multi-cluster architecture introduces a massive observability challenge. If a Kratix Pipeline fails, the logs are in the Platform cluster. If the physical database fails, the logs are in the Worker cluster. In this episode, we build a centralized monitoring stack using Prometheus and Grafana.

Kratix Ep 6: FluxCD GitOps Integration

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

If your organization prefers Flux over ArgoCD, Kratix supports it natively without any modifications to the Platform Cluster. Because Kratix simply writes standard YAML to a Git repository, any GitOps controller can act as the delivery agent. In this episode, we configure FluxCD on the Worker Cluster.

Kratix Ep 5: ArgoCD GitOps Integration

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

In this episode, we learn HOW to execute the GitOps pull model in practice. We will configure ArgoCD on a Worker Cluster to continuously sync the Redis StatefulSet YAML generated by our Kratix Pipeline, ensuring you understand the mechanics of the State Store.

Kratix Ep 4: Core Concepts Deep Dive (How-To)

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

Enough theory. It’s time to look at the YAML. In this episode, we build the E-Commerce Redis Promise line-by-line. We will examine the API schema, the Pipeline configuration, and the Destination selectors that make multi-cluster deployment possible, ensuring you understand exactly how Kratix executes your logic.

Crossplane Ep 10: Introduction to Composition Functions

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

YAML is excellent for configuration, but terrible for programming. As your Platform scales, you will inevitably need for loops, complex if/else logic, and external API calls. In this final intermediate episode, we introduce Composition Functions—the architecture that allows you to write Crossplane logic in Turing-complete languages.

Crossplane Ep 9: Troubleshooting Sync Errors

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

When you run terraform apply, you get immediate red text in your console if an AWS API call fails. Because Crossplane is an asynchronous control loop, kubectl apply always succeeds immediately. When a database fails to boot 10 minutes later, how do you find the error? In this episode, we learn the Crossplane troubleshooting cascade.

Crossplane Ep 8: Managing Dependencies Between Resources

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

If a Composition provisions both an AWS VPC and a Subnet, the Subnet physically cannot be created until the VPC exists and returns an ID. In Terraform, you use implicit dependency mapping (e.g., vpc_id = aws_vpc.main.id). In Crossplane, we manage this using Cross-Resource References and Selector matching.

Crossplane Ep 7: Environment Configs

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

If your company has three clusters (Development, Staging, and Production), you do not want to write three different Compositions for the same RDS database. In this episode, we learn how to use Crossplane EnvironmentConfigs to inject global context (like AWS Account IDs, VPC IDs, and Regions) dynamically into your Compositions.

Crossplane Ep 6: Patching and Transforms

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

In Episode 5, we hardcoded our RDS instance size to 20GB. If a developer asked for 50GB in their Claim, Crossplane ignored it. In this episode, we explore the Patcher, learning how to dynamically route data from the Composite Resource (XR) into the physical Managed Resources (MRs).

Docker Ep 5: Docker Compose for Local Microservices

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

Running 10 docker run commands manually with complex flags is tedious and error-prone. Docker Compose allows you to define and run your entire multi-container infrastructure declaratively in a single YAML file.

Docker Ep 4: Volumes & Data Persistence

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

By default, all files created inside a container are stored on a writable container layer. When that container is deleted, the data is destroyed. Docker Volumes solve this by storing data outside the container filesystem.

Docker Ep 3: Docker Networking Deep Dive

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

How do two containers on the same host talk to each other without exposing ports to the public internet? Docker uses Linux virtual network interfaces (veth pairs) connected to a software bridge.

Docker Ep 2: Writing Production Dockerfiles

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

Shipping a 1GB Docker image containing compilers, debuggers, and build tools to production is a security nightmare. Multi-Stage Builds allow you to separate the build environment from the tiny runtime container.

Docker Ep 1: Architecture & Container Primitives

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

Containers do not exist as physical entities inside the Linux kernel. A “container” is simply a standard Linux process isolated via Namespaces, throttled by cgroups, and mounted on an Overlay2 union filesystem.

Pulumi Ep 10: Using Native Providers (AWS Classic vs AWS Native)

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

Did you know that the @pulumi/aws package you have been using is actually built on top of Terraform? In this final intermediate episode, we explore the difference between ‘Bridged’ providers and ‘Native’ providers, and learn how @pulumi/aws-native directly communicates with the AWS Cloud Control API.

Pulumi Ep 9: Pulumi Packages and the Registry

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

Platform Engineering is rarely confined to a single cloud. You often need to provision AWS servers, configure GitHub repositories, and set up DataDog dashboards simultaneously. In this episode, we learn how to leverage the Pulumi Registry to install third-party Providers and orchestrate multi-cloud deployments from a single TypeScript file.

Pulumi Ep 8: Cross-Stack References (Micro-Stacks)

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

Deploying your entire infrastructure (Networking, Databases, Kubernetes, and Frontend) in a single Pulumi stack is dangerous. A tiny typo in an S3 bucket configuration could accidentally trigger the destruction of your VPC. In this episode, we learn how to architect Micro-Stacks and stitch them together using StackReference.

Pulumi Ep 7: Abstraction with ComponentResources

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

Terraform relies on Modules for abstraction, which are essentially isolated directories of HCL files. Pulumi takes a much more elegant approach. Because we are using a real programming language, we can abstract complex architectures into reusable TypeScript Classes called ComponentResources.

Pulumi Ep 6: Loops and Conditional Infrastructure

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

Welcome to the Intermediate Tier. The true advantage of using a general-purpose programming language for IaC is access to native control flow. In this episode, we will dynamically generate Subnets and Security Group rules using native array mapping and conditional logic based on environment flags.

TS Ep 24: The Polymorphic `this` Type & Fluent APIs

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

An in-depth analysis of the polymorphic this type in TypeScript. Learn how returning : this preserves subclass type identities during method chaining, build type-safe Fluent Builder APIs, and use explicit this parameters for callback binding safety.

TS Ep 23: Static Members, Static Blocks, and Singletons

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

An in-depth analysis of static class members in TypeScript. Learn how static properties attach to constructor functions, static access control, static blocks (static {}), static inheritance, and implementing the Singleton Pattern using private constructors.

TS Ep 22: Abstract Classes & Template Method Pattern

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

An in-depth guide to Abstract Classes in TypeScript. Learn how abstract class prevents direct instantiation, enforcing method implementation contracts on subclasses while sharing concrete base logic using the Template Method design pattern.

TS Ep 21: Class Inheritance, `super()`, and the `override` Keyword

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

An in-depth exploration of class inheritance in TypeScript. Learn how extends establishes prototypal chain linkages, super() constructor constraints, method overriding with super.method(), and using TypeScript 4.3+ override modifier to prevent silent refactoring bugs.

CKAD Ep 5: Storage & Persistent Workloads

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

Containers are ephemeral by default—when a container restarts, all data written to its local filesystem is lost. On the CKAD exam, you must demonstrate how to attach persistent storage to Pods using PVCs and StorageClasses.

TS Ep 20: Implementing Interfaces (`implements` Keyword)

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

An in-depth analysis of interface implementation in TypeScript. Learn how implements validates class structure, why implements does not infer method parameter types automatically, implementing multiple interfaces, and public contract enforcement.

CKAD Ep 4: Services, Ingress & Network Policies

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

Services provide stable IP addresses for ephemeral Pods, Ingress controllers route HTTP/S domain traffic at Layer 7, and NetworkPolicies act as Pod-level firewalls. In this episode, we build production manifests for all three.

TS Ep 19: Getters, Setters, and Asymmetric Accessors

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

An in-depth analysis of class accessors in TypeScript. Learn how get and set intercept reading and writing, computed properties, backing field naming patterns, and TypeScript 4.3+ Asymmetric Accessor Types.

CKAD Ep 3: ConfigMaps, Secrets & Security Contexts

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

Decoupling application code from environment configuration and enforcing security policies is tested extensively on the CKAD exam. You must know how to pass ConfigMaps and Secrets into Pods as environment variables or volume mounts.

TS Ep 18: Parameter Properties — Concise Class Initializations

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

Learn how TypeScript parameter properties compress field declarations, constructor parameter typing, and this assignments into one line. Understand compilation behavior, inheritance interaction with super(), and common duplicate identifier gotchas.

CKAD Ep 2: Deployments, Rollouts & Canary Releases

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

Deployments manage ReplicaSets to automate application rollouts and rollbacks. The CKAD exam requires you to perform image updates, scale replicas, track revision history, and execute emergency rollbacks within seconds.

TS Ep 17: Access Modifiers & Hard Private Fields (#)

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

An in-depth analysis of class encapsulation. Understand the visibility matrix of public, private, and protected modifiers, inheritance rules in subclasses, compile-time type erasure, and how ES2022 hard private fields (#) provide true runtime isolation.

CKAD Ep 1: Multi-Container Pod Patterns & Design

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

Multi-container Pod patterns allow containers to share storage and network namespaces to extend functionality without modifying application source code. Designing these patterns under time pressure is a core domain of the CKAD exam.

TS Ep 16: Class Basics, Field Declarations, and Constructors

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

An in-depth guide to TypeScript classes. Learn how field declarations differ from standard ES6 JavaScript, how strictPropertyInitialization eliminates uninitialized field bugs, readonly class fields, and the Definite Assignment Assertion operator (!).

TS Ep 2: Intermediate TypeScript — Generics, Type Helpers, and Mapped Types

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

An in-depth guide to intermediate TypeScript type transformations. Master generic functions and constraints (extends), indexed access types, keyof/typeof operators, built-in helpers (Pick, Omit, Record, ReturnType), and mapped type transformations.

TS Ep 40: Key Remapping with `as`

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

Take your Mapped Types to the absolute limit. Learn how to compute entirely new string names for keys on the fly using Template Literal Types, and discover how to completely filter out properties by returning never during key mapping.

TS Ep 39: Mapped Type Modifiers (`+`, `-`, `?`, `readonly`)

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

An in-depth guide to Mapped Type Modifiers in TypeScript. Learn how to preserve, add (+), or strip (-) property modifiers like readonly and ?. We explore how these mapping modifiers power TypeScript’s built-in Partial, Required, and Readonly utility types.

TS Ep 38: Mapped Types (Basics)

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

An in-depth guide to Mapped Types in TypeScript. Learn how to use the [K in Union] syntax to iterate over literal unions, transform existing object properties using keyof and Indexed Access, and build strict state validation maps that perfectly mirror domain models.

TS Ep 37: Built-in Utility Types (`ReturnType` & `Parameters`)

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

An in-depth guide to ReturnType<T> and Parameters<T>. Learn how to reverse-engineer third-party library functions, the requirement of typeof, tuple indexing to extract specific arguments, and the underlying infer keyword mechanics powering these utilities.

TS Ep 36: Built-in Utility Types (`Extract` and `Exclude`)

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

An in-depth guide to the Extract and Exclude utility types. Understand the fundamental difference between Object manipulation (Pick/Omit) and Union manipulation (Extract/Exclude), extracting by object signature in discriminated unions, and their underlying distributive conditional type mechanics.

TS Ep 35: Built-in Utility Types (`Record`)

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

An in-depth look at the Record<K, V> utility type. Learn how to type arbitrary string dictionaries, enforce exhaustive key mapping using Unions, and combine Record with other utilities to model complex domain configurations.

TS Ep 34: Built-in Utility Types (`Pick` and `Omit`)

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

An in-depth guide to Pick and Omit utility types in TypeScript. Learn under-the-hood mapped type implementations (Pick via mapped types, Omit via Exclude), key constraints differences, building public API DTOs, and the selection decision matrix.

TS Ep 33: Built-in Utility Types (`Partial`, `Required`, `Readonly`)

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

An in-depth analysis of TypeScript’s foundational object utility types. Learn how Partial<T>, Required<T>, and Readonly<T> transform property modifiers, their under-the-hood mapped type implementations (?, -?, readonly), and shallow immutability limits.

TS Ep 32: Multiple & Dependent Generic Parameters

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

An in-depth guide to using multiple generic parameters in TypeScript. Learn dependent type parameter relationships, object merging signatures, and how to solve the Partial Generic Inference Trap using higher-order curried functions.

TS Ep 31: Default Generic Arguments (``)

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

An in-depth guide to Default Generic Arguments in TypeScript. Learn how assigning fallback types (<T = Default>) simplifies generic interfaces, combining constraints with defaults (<T extends Constraint = Default>), and enforcing strict parameter ordering rules.

TS Ep 30: Generic Constraints (`extends` Keyword)

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

An in-depth guide to Generic Constraints in TypeScript. Learn why unconstrained <T> limits property access, how <T extends Shape> establishes lower type bounds, why generic constraints outperform interface parameter types, and how to constrain keys using <K extends keyof T>.

TS Ep 29: Introduction to Generics — Type Parameters ()

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

An in-depth introduction to Generics in TypeScript. Learn how type parameters (<T>) bridge reusable logic with strict type safety, generic type inference, generic interfaces (ApiResponse<T>), and generic classes.

TS Ep 28: The `typeof` Type Operator (Value to Type Space)

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

An in-depth guide to the typeof operator in Type Space. Learn the distinction between Value Space and Type Space, reverse-engineering types from runtime objects and functions, combining keyof typeof, and deriving single-source-of-truth types.

TS Ep 27: The `keyof` Type Operator

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

An exhaustive guide to the keyof operator in TypeScript. Learn how keyof extracts property key unions from object interfaces, array/tuple types, index signatures, and how to combine keyof with Generics to build type-safe property accessors.

TS Ep 26: Indexed Access Types (`T[K]`)

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

An in-depth guide to Indexed Access Types (T[K]). Learn how to look up specific property types from object shapes, perform nested indexing, index with unions T['a' | 'b'], extract array element types using [number], and enforce DRY type architectures.

TS Ep 25: Interfaces vs. Type Aliases — The Definitive Comparison

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

An exhaustive comparison of interface vs type in TypeScript. Understand Declaration Merging, extends vs Intersections (&), compiler performance during type checking, and the precise decision matrix for choosing between them.

Terraform Ep 10: Remote State Backends and Concurrency Locking

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

Local state files are fine for solo learning, but catastrophic for team environments. In this episode, we will solve the ‘state file drift’ problem by configuring a Remote Backend on AWS S3, and preventing simultaneous executions using DynamoDB locking.

Terraform Ep 9: Architecting Reusable, Production-Grade Modules

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

Modules are the functions of the Terraform ecosystem. In this episode, we will build a reusable AWS VPC module from scratch, define explicit inputs and outputs, and consume it from a separate Root Module. Stop copy-pasting code and start building a self-service infrastructure catalog.

Terraform Ep 8: Generating Nested Configurations with Dynamic Blocks

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

While ‘count’ and ‘for_each’ duplicate entire resources, ‘dynamic’ blocks duplicate nested configurations inside a single resource. Discover how to build highly flexible, list-driven Security Groups and Route Tables without repeating HCL blocks.

Terraform Ep 7: Advanced Looping Strategies (count vs for_each)

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

Copy-pasting resource blocks is a cardinal sin in Platform Engineering. In this episode, we will deploy identical infrastructure fleets using loops. You will learn the critical differences between ‘count’ and ‘for_each’, and why ‘count’ can accidentally destroy your production servers if used incorrectly.

Terraform Ep 6: Local Values, Built-in Functions, and Interpolation

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

Terraform is not just static configuration; it is a powerful programming language. In this episode, we explore how to perform string interpolations, use mathematical functions, and centralize complex expressions using the ’locals’ block to keep your code DRY.

Go Ep 10: Goroutines & Channel Basics

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

Do not communicate by sharing memory; instead, share memory by communicating. Goroutines and Channels form the core primitives of Go’s concurrency model.

Go Ep 9: Implicit Interfaces & Polymorphism

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

If it walks like a duck and quacks like a duck, Go treats it like a duck. Interfaces in Go are satisfied implicitly, creating loose coupling and high testability across packages.

Go Ep 8: Methods & Struct Composition

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

Go favors Composition over Inheritance. By embedding structs inside other structs, you automatically promote fields and methods without the rigid coupling of object-oriented class hierarchies.

Go Ep 7: Pointers & Memory Allocation

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

Go is a pass-by-value language. When you pass an argument to a function, Go creates a copy. Pointers allow you to share memory directly across function boundaries without copying large data structures.

Cara Fix Error OOMKilled (Exit Code 137) di Kubernetes Pod

Sat, 08 Aug 2026 00:00:00 +0000

Mengalami error OOMKilled (Exit Code 137) saat menjalankan aplikasi di Kubernetes? Masalah ini terjadi ketika penggunaan memori kontainer melebihi batas resources.limits.memory.

1. Penyebab Utama Error
#

Secara teknis, OOM (Out Of Memory) Killer pada Linux Kernel akan menghentikan proses yang mengonsumsi RAM berlebih.

2. Solusi Cepat
#

Naikkan batas RAM pada manifest YAML: