Platform Engineering Training in Islamabad

🏗️ Platform Engineering / IaC Track

Currently available in Islamabad

---

Platform Engineering is the discipline of building the internal infrastructure, tooling, and automated workflows that let development teams ship software reliably and at speed — without becoming DevOps experts themselves. It sits at the intersection of cloud infrastructure, automation, developer experience, and security.

This track is designed for engineers who want to move beyond basic server management and CI/CD scripts into the world of Infrastructure as Code, Kubernetes-native deployments, GitOps, and internal developer platforms. These are the skills that command the highest salaries in cloud infrastructure roles — and the ones most underrepresented in Pakistan's training market.

💡 Why Platform Engineering

---

Modern engineering organisations have split "DevOps" into two distinct roles: application-side engineers who own CI/CD and deployments, and platform engineers who own the infrastructure, Kubernetes clusters, IaC codebases, and the internal tooling that everyone else depends on. Platform engineers are:

• Among the highest-paid infrastructure specialists in the market
• In demand at every company running Kubernetes or multi-cloud infrastructure
• Increasingly required for senior cloud and SRE roles even at Pakistani IT firms and remote teams
• Building the foundations that let 10 developers ship as fast as 50 used to

📚 Module Breakdown

---

Week 1 — Phase 0: Foundations & Linux / Networking Essentials

Platform engineering sits on top of networking and Linux fundamentals. This phase ensures every student has the baseline before touching any cloud or IaC tooling.

1. Linux deep dive: process management, systemd, file system, permissions, and shell scripting
2. Bash scripting for automation: writing production-grade shell scripts
3. Networking fundamentals: TCP/IP, DNS, subnets, VPCs, load balancers, and firewalls
4. TLS/SSL certificates: how they work, Let's Encrypt, and certificate management at scale
5. SSH hardening, key management, and bastion host patterns
6. Git advanced workflows: branching strategies, rebasing, signed commits, and monorepo patterns
7. YAML and JSON mastery — the universal language of infrastructure configuration

Week 1–2 — Phase 1: Containers & Docker in Depth

Kubernetes runs containers. Before orchestrating them, you need to understand them at the level a platform engineer needs — not just "how to run docker run".

1. Docker architecture: daemon, images, layers, registries, and the build cache
2. Writing production-quality Dockerfiles: multi-stage builds, minimal base images, security scanning
3. Docker Compose for local development environments
4. Container registries: AWS ECR, Docker Hub, and GitHub Container Registry
5. Image tagging strategies, versioning, and promotion workflows
6. Container security: running as non-root, read-only filesystems, and vulnerability scanning with Trivy
7. Docker networking: bridge, host, overlay, and inter-container communication
8. Volumes and persistent storage patterns for stateful containers

Week 2–3 — Phase 2: Infrastructure as Code — Terraform

Terraform is the most widely adopted IaC tool in the industry. This phase covers it from fundamentals through enterprise-scale patterns.

1. Terraform core concepts: providers, resources, data sources, state, and the plan/apply lifecycle
2. HCL language deep dive: variables, locals, outputs, expressions, and functions
3. Terraform state management: local vs remote state, S3 + DynamoDB locking, state isolation
4. Modules: writing reusable, versioned Terraform modules for your organisation
5. Workspaces and environment promotion: dev → staging → production patterns
6. Provisioning AWS infrastructure with Terraform: VPC, subnets, security groups, EC2, RDS, S3, IAM
7. Provisioning EKS (managed Kubernetes) clusters with Terraform
8. Terraform with GitHub Actions: automated plan on PR, apply on merge
9. Terraform Cloud / Atlantis for team-based IaC workflows
10. Drift detection: identifying and reconciling infrastructure that has diverged from code
11. Importing existing infrastructure into Terraform state
12. Testing Terraform with Terratest and checkov for policy compliance

Week 3 — Phase 3: Infrastructure as Code — Pulumi & AWS CDK

Pulumi and AWS CDK let you define infrastructure in real programming languages (TypeScript, Python, Go) — a major shift for teams that prefer code over DSLs.

1. Pulumi vs Terraform: when to use which and why they coexist in real organisations
2. Pulumi with TypeScript: provisioning AWS resources using real programming constructs
3. Pulumi stacks, state backends, and secrets management
4. AWS CDK fundamentals: constructs, stacks, apps, and the CDK toolkit
5. Writing CDK stacks in TypeScript: VPC, ECS, RDS, Lambda, and API Gateway
6. CDK Constructs Library: using L1, L2, and L3 constructs effectively
7. CDK Pipelines: self-mutating CI/CD pipelines for infrastructure
8. Comparing Terraform, Pulumi, and CDK on a real infrastructure project

Week 3–4 — Phase 4: Kubernetes in Depth

The core of platform engineering. This phase moves far beyond "how to deploy a pod" into the cluster-level thinking platform engineers need.

1. Kubernetes architecture: control plane, worker nodes, etcd, API server, scheduler, and kubelet
2. Core objects: Pods, Deployments, ReplicaSets, StatefulSets, DaemonSets, Jobs, and CronJobs
3. Services, Ingress, and Ingress Controllers (NGINX, AWS ALB Ingress)
4. ConfigMaps and Secrets: managing application configuration and sensitive data
5. Persistent Volumes, Persistent Volume Claims, and Storage Classes
6. Namespaces, RBAC, and multi-tenancy: isolating teams and workloads on shared clusters
7. Resource requests, limits, LimitRanges, and ResourceQuotas
8. Horizontal Pod Autoscaler (HPA) and Vertical Pod Autoscaler (VPA)
9. Node selectors, taints, tolerations, and affinity rules for workload placement
10. Kubernetes networking: CNI plugins, kube-proxy, CoreDNS, and network policies
11. Health checks: liveness, readiness, and startup probes
12. EKS in production: managed node groups, Fargate profiles, and cluster add-ons
13. GKE Autopilot: hands-off cluster management on Google Cloud
14. Cluster upgrades, node pool management, and zero-downtime maintenance

Week 4 — Phase 5: GitOps — ArgoCD & FluxCD

GitOps is the operating model where Git is the single source of truth for both application code and infrastructure state. ArgoCD and FluxCD are the two dominant tools that enforce it.

1. GitOps principles: declarative infrastructure, version control as the control plane, and reconciliation loops
2. ArgoCD architecture: application controller, repo server, API server, and Redis
3. Deploying ArgoCD to a cluster and connecting it to a Git repository
4. ArgoCD Applications, ApplicationSets, and the App of Apps pattern
5. Sync policies: manual vs automated sync, self-healing, and pruning
6. Managing multiple clusters and environments with ArgoCD
7. FluxCD: the CNCF-native alternative — source controller, kustomize controller, helm controller
8. Kustomize: environment-specific overlays without duplicating manifests
9. Helm: packaging Kubernetes applications, writing custom charts, and using Helm with ArgoCD/Flux
10. Secrets in GitOps: Sealed Secrets and External Secrets Operator (ESO) with AWS Secrets Manager
11. Progressive delivery: blue/green and canary deployments with Argo Rollouts
12. Image update automation: automatically promoting new container images through environments

Week 4–5 — Phase 6: Observability & Platform Security

A platform is only production-ready when you can see what it's doing and trust that it's secure. This phase covers the full observability stack and cloud security fundamentals.

1. The three pillars of observability: metrics, logs, and traces
2. Prometheus: scraping metrics, writing PromQL queries, and configuring alerting rules
3. Grafana: building dashboards for cluster health, application performance, and cost
4. Loki: log aggregation for Kubernetes workloads without indexing overhead
5. OpenTelemetry: instrumenting applications for distributed tracing (language-agnostic)
6. Alerting pipelines: Alertmanager routing to PagerDuty, Slack, and email
7. AWS CloudWatch: metrics, log groups, container insights, and CloudWatch alarms
8. IAM security hardening: least privilege, permission boundaries, and service control policies
9. Kubernetes security: Pod Security Standards, OPA/Gatekeeper policy enforcement
10. Secrets management at scale: AWS Secrets Manager, HashiCorp Vault basics
11. Supply chain security: signing container images with Cosign, SBOM generation
12. FinOps: cloud cost visibility, rightsizing, Reserved Instances, and Savings Plans

Week 5 — Phase 7: Internal Developer Platform (IDP) Design

The capstone phase. You will design and build a minimal but real Internal Developer Platform — the infrastructure product that platform teams build for their engineering organisations.

1. What is an Internal Developer Platform: golden paths, self-service, and developer experience
2. Backstage (by Spotify): setting up a developer portal with a service catalogue and TechDocs
3. Scaffolding templates: letting developers create new services from standardised templates via Backstage
4. Platform team topology: how to structure a platform team and define its SLOs
5. Capstone project: provision a full environment (VPC, EKS, monitoring stack, GitOps pipeline) from scratch using Terraform + ArgoCD, and expose it to a development team via a Backstage portal

📅 Schedule & Timings

Choose one group only based on your availability. Max 5 candidates per group to ensure individual attention and hands-on lab support.

Weekday Groups:

• Group 1: Mon–Wed, 10 AM – 1 PM
• Group 2: Mon–Wed, 4 PM – 7 PM

Weekend Groups:

• Group 3: Sat & Sun, 10 AM – 2 PM
• Group 4: Sat & Sun, 4 PM – 8 PM

📍 Location: In-house training in Islamabad
📱 Online option may be arranged for out-of-city participants

☁️ Cloud Platforms Covered

• AWS — primary platform (EKS, EC2, RDS, S3, IAM, Secrets Manager, CloudWatch)
• Google Cloud — GKE Autopilot, Cloud Build, Artifact Registry
• Azure — AKS and Bicep covered as supplementary references

🛠️ Tools Covered

• IaC: Terraform, Pulumi, AWS CDK
• Containers: Docker, Docker Compose, AWS ECR, Trivy
• Kubernetes: kubectl, Helm, Kustomize, EKS, GKE Autopilot
• GitOps: ArgoCD, FluxCD, Argo Rollouts, Sealed Secrets, ESO
• Observability: Prometheus, Grafana, Loki, OpenTelemetry, Alertmanager
• Security: OPA/Gatekeeper, Cosign, HashiCorp Vault, AWS Secrets Manager
• IDP: Backstage
• CI/CD: GitHub Actions, Atlantis, CDK Pipelines

✅ Prerequisites

• Comfortable with Linux command line and basic shell scripting
• Familiarity with at least one programming language (any)
• Basic understanding of how web applications and APIs work
• No prior Kubernetes or Terraform experience required

🎯 Who This Is For

• Backend or full-stack developers who want to own infrastructure
• DevOps engineers looking to specialise in platform and IaC roles
• Cloud engineers targeting senior AWS / GCP / Azure positions
• Engineers preparing for remote roles at international companies

💳 Course Fee & Booking

• ⌛ Duration: 5 Weeks
• 🔒 Seats: 5 only per group

👉 Click here to book via WhatsApp