Tutorial on Dev & Platform Engineering Hub

Kratix Ep 11: Full IDP Integration with Backstage

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

While kubectl is powerful, it is not a Developer Portal. In this episode, we integrate Kratix with Backstage, creating a unified Web UI where developers can browse the service catalog, request infrastructure, and monitor their applications without ever opening a terminal.

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 9: Promise CI/CD with GitHub Actions

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

Platform Engineers write code too. When you build a complex Promise, you must compile the Pipeline container, lint the YAML, and safely deploy it to the Platform Cluster. In this episode, we build a robust GitHub Actions CI/CD pipeline to automate the lifecycle of Kratix Promises.

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 7: Secrets Management with ESO and Vault

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

GitOps has one fatal flaw: You cannot commit secrets to a Git repository. When Kratix generates a Redis password during a Pipeline execution, how does it securely deliver that password to the Worker Cluster? In this episode, we solve the GitOps secrets problem using HashiCorp Vault and ESO.

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.

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 15: Building an IDP with Backstage

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

We have built the APIs, the translation engine, the GitOps pipeline, and the security webhooks. But developers still have to write YAML to request a database. In this final episode, we integrate Crossplane with Backstage to create the ultimate Internal Developer Portal (IDP).

Crossplane Ep 14: Custom Composition Webhooks

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

OpenAPI schema validation (like type: integer) is too basic for enterprise security. What if you need to enforce that a database’s storage size is an even number, or that the requested environment matches a specific regex? In this episode, we write a Kubernetes Validating Webhook in Go to intercept and inspect Crossplane Claims.

Crossplane Ep 13: Provider Families and Performance

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

If you install the monolithic provider-aws package into a small EKS cluster, your Kubernetes API server might crash. AWS has over 1,000 resources, meaning Crossplane will inject 1,000 CRDs and run a massive Go controller in memory. In this episode, we learn how to architect high-performance Crossplane clusters using Provider Families.

Crossplane Ep 12: GitOps with ArgoCD and Crossplane

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

If you are running kubectl apply -f my-database.yaml from your laptop, you are doing it wrong. In modern Platform Engineering, no human should ever talk directly to the Kubernetes API. In this episode, we configure ArgoCD to automatically deploy Crossplane XRs directly from a GitHub repository.

Crossplane Ep 11: Writing Composition Functions in Go

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

In Episode 10, we learned that Composition Functions allow us to escape the limitations of YAML. In this episode, we will write a custom Go program that dynamically generates an array of AWS Subnets based on a single integer provided by the Application Developer.

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).

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 15: Multi-Language Components (MLC)

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

In Episode 7, we built a reusable TypeScript ComponentResource. But what if the Data Science team wants to use your component in their Python IaC? Historically, they couldn’t. Pulumi Multi-Language Components (MLC) solves this by using gRPC to project your TypeScript code across all supported languages.

Pulumi Ep 14: Policy as Code with CrossGuard

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

In Terraform, enforcing security rules requires external tools like OPA (Open Policy Agent) and Rego. Pulumi provides a native Policy-as-Code engine called CrossGuard. In this episode, we will write TypeScript policies that act as a strict firewall, preventing developers from provisioning insecure infrastructure.

Pulumi Ep 13: Unit Testing Infrastructure (Jest)

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

Testing infrastructure usually means deploying it to a sandbox, waiting 15 minutes, running a bash script to ping an IP, and tearing it down. Because Pulumi is TypeScript, we can use the industry-standard Jest testing framework to write offline, millisecond unit tests to validate our infrastructure logic before we ever touch the cloud.

Pulumi Ep 12: Authoring Dynamic Providers

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

What happens when you need to provision a resource in a system that doesn’t have an official Pulumi plugin? In Terraform, you must write complex Go code, compile a binary, and distribute it. In Pulumi, you can author a Dynamic Provider directly in your index.ts file using pure TypeScript.

Pulumi Ep 11: The Automation API (Embedded Pulumi)

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

Running pulumi up from a CLI is great for Platform Engineers, but what if you want to build a self-service Internal Developer Portal (IDP) where developers click a button on a web page to provision a database? The Pulumi Automation API allows you to embed the entire Pulumi Engine inside your own Node.js, Python, or Go applications.

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.

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.

Terraform Ep 15: Infrastructure Unit Testing with Terratest (Golang)

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

Running ’terraform plan’ is not enough to guarantee your infrastructure works. In this final episode, we bridge the gap between DevOps and Software Engineering by writing automated Golang tests using Terratest. We will programmatically provision infrastructure, assert its correctness, and tear it down.

Terraform Ep 14: Achieving DRY Architecture with Terragrunt

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

As your Terraform codebase scales across dozens of microservices and environments, you will find yourself copy-pasting the same ‘backend’ and ‘provider’ blocks repeatedly. Terragrunt is a powerful wrapper that eliminates this repetition, allowing you to define global configurations once.

Terraform Ep 13: Advanced State Manipulation (Surgical Refactoring)

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

Refactoring HCL code is dangerous. If you rename a resource block, Terraform will attempt to destroy the old resource and recreate it. In this episode, we learn how to use ‘moved’ blocks and the state CLI to refactor code safely, preventing catastrophic database deletions.

Terraform Ep 12: CI/CD Automation with Terraform Cloud and GitHub Actions

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

Running ’terraform apply’ from a local laptop is a major security and compliance risk. In this episode, we transition to a GitOps workflow. You will learn how to automate Terraform plans on Pull Requests, and automatically apply changes upon merging to the main branch using GitHub Actions.

Terraform Ep 11: Managing Multi-Environment Architecture (Workspaces vs Directories)

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

Welcome to Tier 3: Advanced Platform Engineering. You now know how to write reusable modules and store state remotely. But how do you safely deploy identical infrastructure to both Staging and Production without them colliding? We explore Workspaces and Directory Isolation.

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.

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 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.