AI Coding Assistants 1
▼
Uses GitHub Copilot for accelerating IaC code writing: Terraform resources, Dockerfile, CI/CD workflows. Understands AI suggestion limitations and always verifies generated code. Applies Copilot Chat for explaining complex Kubernetes configurations.
Effectively uses Copilot for platform tasks: generating Helm templates, Ansible roles, monitoring configs. Configures Copilot workspace context for accurate suggestions. Creates prompt patterns for typical IaC tasks. Reviews AI-generated code for security and best practices.
Implements Copilot in platform workflows: Copilot for CLI for kubectl/terraform, code review suggestions. Creates organizational context files for improving suggestion quality. Develops guidelines for safe AI usage in infrastructure-as-code with secrets exposure awareness.
Defines organizational GitHub Copilot strategy: Enterprise deployment, usage policies, security review process. Leads AI-assisted development ROI measurement. Creates governance framework for AI-generated infrastructure code. Integrates Copilot into developer experience metrics.
Alerting & On-Call 1
▼
Understands SLI, SLO, SLA concepts and their differences for platform services. Monitors error budget via Grafana dashboards. Creates basic SLI metrics: availability, latency, throughput. Participates in SLO review meetings and escalates when burn rate is exceeded.
Configures SLO monitoring for platform services: multi-window burn rate alerts, error budget policies. Creates SLO dashboards with burn-down visualization. Defines SLIs for various service types (API, batch, streaming). Implements automated SLO reporting for stakeholders.
Designs SLO framework for IDP: automated SLO tracking (Sloth, Pyrra), error budget-driven release process. Creates self-service SLO configuration for teams. Implements SLO-based alerting instead of threshold-based. Integrates SLO compliance into deployment pipeline for gating.
Defines organizational SLO strategy: tiered SLO targets, error budget governance, SLA management process. Leads SRE practice adoption through SLO framework. Designs organizational error budget policy: freeze deployments, allocate engineering time on depletion.
Algorithms & Data Structures 1
▼
Understands the fundamentals of Algorithms & Complexity at a basic level. Applies simple concepts in work tasks using Go/Python/HCL. Follows recommendations from senior developers when solving problems.
Independently applies algorithmic thinking in platform engineering: evaluates rate limiting algorithm behavior, understands service discovery strategies, selects resource allocation algorithms for multi-tenant isolation. Analyzes complexity of platform routing and request processing operations.
Applies algorithmic thinking to platform engineering: rate limiting algorithms (token bucket, leaky bucket), service discovery algorithms for dynamic infrastructure, resource quota enforcement algorithms. Designs efficient routing and load distribution algorithms for multi-tenant platform services.
Evaluates algorithmic complexity of platform solutions: scheduling algorithms for K8s, routing in service mesh, index strategies for log storage. Leads optimization of IDP critical path components. Conducts design reviews focused on scalability and computational efficiency.
CI/CD 2
▼
Creates basic GitHub Actions workflows for CI of platform components: lint, test, build. Uses ready-made actions from Marketplace. Configures triggers (push, PR) and matrix builds. Understands workflow YAML syntax and secrets management.
Develops reusable workflows for standardizing CI/CD on the platform: composite actions, workflow dispatch. Configures self-hosted runners for private infrastructure. Optimizes CI time through dependency caching and parallel jobs. Creates custom actions.
Designs CI/CD platform based on GitHub Actions for IDP: reusable workflow library, required workflows, environment protection rules. Implements OIDC authentication for secure deployment. Creates self-service CI/CD for teams through template repositories and Backstage.
Defines organizational CI/CD strategy on GitHub Actions: governance, compliance checks, security scanning pipeline. Leads migration from legacy CI to Actions. Designs runner infrastructure with autoscaling (ARC). Optimizes costs and performance at enterprise level.
Writes basic .gitlab-ci.yml pipelines for platform projects: stages, jobs, artifacts. Uses predefined variables and rules for conditional execution. Configures Docker executor for runners. Understands caching and job dependencies.
Creates templated CI/CD pipelines (include/extends) for standardizing platform processes. Configures GitLab Runner fleet with autoscaling in Kubernetes. Implements parent-child pipelines for complex deployments. Uses environments and review apps for preview.
Designs CI/CD platform on GitLab for IDP: CI/CD component catalog, compliance pipelines, security scanning integration. Creates golden pipeline templates for teams. Implements GitLab Releases and feature flags for controlled rollout through the platform.
Defines organizational GitLab CI/CD strategy: instance vs SaaS, runner infrastructure, license optimization. Leads internal component library creation. Designs compliance framework with automatic audit trails. Integrates GitLab with IDP for end-to-end developer workflow.
Cloud Providers 2
▼
Works with basic AWS services for the platform: EC2, S3, VPC, IAM. Uses AWS Console and CLI for managing resources in dev account. Understands the shared responsibility model and IAM policy basics. Configures CloudWatch for basic platform resource monitoring.
Manages platform AWS infrastructure: EKS, RDS, ElastiCache, SQS/SNS. Configures AWS Organizations and multi-account strategy for environment isolation. Uses AWS Config and CloudTrail for compliance. Optimizes costs through Reserved Instances and Savings Plans.
Designs AWS architecture for IDP: Landing Zone, Control Tower, Service Catalog for self-service. Implements AWS SSO and federation for platform authentication. Creates centralized networking (Transit Gateway, PrivateLink). Automates account vending through IaC.
Defines organizational AWS strategy: Well-Architected review, cost governance, security baseline. Leads AWS migration or optimization of existing infrastructure. Designs multi-region DR strategy. Manages AWS Enterprise Support and TAM interactions.
Understands GCP platform services: GKE, Cloud Run, and Cloud Build. Configures basic infrastructure using Terraform with GCP provider. Works with Artifact Registry and Cloud Logging.
Independently configures and manages Google Cloud Platform. Writes IaC for typical tasks. Understands networking and security basics.
Designs infrastructure solutions with Google Cloud Platform. Optimizes cost and performance. Implements best practices and security hardening.
Defines infrastructure strategy with Google Cloud Platform. Establishes IaC standards. Conducts architecture reviews. Optimizes FinOps.
Container Security 1
▼
Runs Trivy/Grype for scanning images in local environment, analyzes CVE reports. Understands the difference between critical/high/medium vulnerabilities and their impact on platform services. Updates base images based on scan results.
Integrates security scanning into the platform CI/CD pipeline: automated Trivy/Snyk on every PR. Configures deployment blocking policies for critical CVEs. Manages allow-lists for known false positives and creates vulnerability triage process for platform components.
Designs comprehensive container security strategy for IDP: runtime scanning (Falco), admission policies (Kyverno/OPA). Implements image signing and verification (cosign + Sigstore). Creates centralized vulnerability dashboard with automated alerts and remediation SLA.
Defines corporate container security framework: SBOM generation, SLSA compliance, supply chain attestation. Coordinates shift-left approach adoption with security team. Manages vulnerability management program for all platform services with MTTR metrics.
Containerization 1
▼
Creates Dockerfiles for platform microservices, understands image layers and caching. Uses multi-stage builds to reduce image size. Works with Docker Compose for local platform component development, configures volume mounting and network connections between services.
Optimizes Docker images for platform services: minimal base images (distroless, Alpine), security scanning in CI. Configures private registries (Harbor, ECR) with retention and rotation policies. Creates standardized base images for development teams as part of the golden path.
Designs containerization strategy for internal platform: image standards, automated vulnerability scanning, image signing (cosign/Notary). Implements BuildKit and CI-level caching for build acceleration. Defines OCI standards and runtime policies for the entire organization.
Defines corporate containerization strategy: image governance, supply chain security (SBOM, SLSA). Manages multi-registry architecture with geo-replication. Implements admission controllers for image validation before deployment. Trains teams on containerization best practices for the platform.
Deployment Strategies 3
▼
Understands blue-green deployment principles and its benefits for zero-downtime on the platform. Performs traffic switching between blue and green environments by following instructions. Verifies health checks of new environment before switch. Participates in rollback when issues arise.
Configures blue-green deployment for platform services: DNS-based or load balancer switching. Automates smoke tests between switches. Manages databases during blue-green (backward compatible migrations). Creates runbooks for blue-green procedures.
Designs blue-green infrastructure for IDP: immutable environments through IaC, automated validation pipeline. Integrates blue-green with ArgoCD and service mesh for seamless switching. Creates self-service blue-green deployment for teams with automatic rollback based on SLI.
Defines zero-downtime deployment strategy: when to use blue-green vs canary vs rolling update. Leads standardization of deployment strategies on the platform. Designs cost-efficient dual-environment approach (spot instances, autoscaling). Creates deployment reliability metrics.
Understands the canary deployment concept and how it differs from blue-green for the platform. Monitors canary release metrics via Grafana/Prometheus. Escalates issues when metrics degrade. Participates in configuring traffic split through ArgoCD Rollouts by following instructions.
Configures canary deployment through Argo Rollouts: AnalysisTemplate, traffic management via Istio/NGINX. Defines canary metrics (error rate, latency p99, saturation). Automates promotion/rollback based on analysis runs. Creates canary templates for platform teams.
Designs canary infrastructure for IDP: multi-metric analysis, header-based routing for internal canary. Integrates canary with observability stack (Prometheus metrics + custom analysis). Creates self-service canary configuration with safe defaults for all teams.
Defines organizational progressive delivery strategy: canary + feature flags + observability as a unified process. Leads automated canary analysis adoption across all services. Designs blast radius management through graduated rollout policies and automatic halts.
Understands the fundamentals of Progressive Delivery. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Independently creates and maintains Progressive Delivery pipelines. Configures CI/CD pipelines. Automates routine operations.
Designs CI/CD architecture with Progressive Delivery. Optimizes pipeline speed and reliability. Implements progressive delivery practices.
Defines DevOps strategy with Progressive Delivery. Establishes CI/CD standards. Implements platform engineering approaches.
DNS & Networking 2
▼
Configures basic CDN (CloudFront, Cloudflare) for platform UI component static assets. Understands caching, TTL and invalidation. Configures custom domains and SSL certificates. Diagnoses caching issues through HTTP headers.
Manages platform CDN infrastructure: cache policies, origin failover, WAF rules. Configures edge functions (CloudFront Functions, Cloudflare Workers) for routing and A/B testing. Optimizes TTFB and cache hit ratio for platform services.
Designs edge architecture for IDP: CDN as part of deployment pipeline, edge-side computing for personalization. Implements multi-CDN strategy with intelligent routing. Creates self-service CDN configuration for teams through IaC modules.
Defines organizational edge strategy: edge computing vs centralized, latency budget, cost optimization. Leads edge platform adoption (Cloudflare Workers, Deno Deploy) for distributed workloads. Designs global traffic management.
Configures Application Load Balancer for platform services: target groups, health checks, routing rules. Understands the difference between ALB/NLB/CLB and their use cases. Configures SSL termination and redirect rules. Debugs 502/503 errors through CloudWatch metrics.
Designs load balancing for the platform: weighted routing for canary, path-based routing for multi-service. Configures global load balancing (Route53, Global Accelerator). Optimizes connection draining and idle timeout. Implements WAF at load balancer level for platform protection.
Develops traffic management architecture for IDP: multi-layer balancing (DNS → GLB → ALB → service mesh). Implements circuit breaking and rate limiting at platform level. Creates self-service load balancer provisioning through Terraform modules for teams.
Defines organizational traffic management strategy: API gateway, service mesh, load balancing as unified architecture. Leads progressive delivery adoption through traffic shifting. Designs multi-region active-active with intelligent failover for critical services.
GitOps 1
▼
Understands basic ArgoCD concepts for managing platform service deployments through GitOps. Follows team procedures for monitoring Application sync health and reviewing deployment logs in ArgoCD. Uses existing Application manifests to deploy platform components such as service meshes, ingress controllers, and observability stacks.
Independently configures ArgoCD as the deployment engine for the internal developer platform. Writes ApplicationSets with matrix and merge generators for multi-cluster platform service delivery. Implements ArgoCD project isolation, sync windows for change management, and webhook integrations for platform CI/CD orchestration.
Designs ArgoCD as the GitOps control plane for the organization's internal developer platform. Implements multi-cluster ArgoCD topology with hub-spoke patterns, ApplicationSet controllers for fleet management, and custom plugins for platform-specific resource types. Optimizes ArgoCD scalability with controller sharding and efficient reconciliation tuning for hundreds of applications.
Defines ArgoCD platform strategy as the foundation of the organization's GitOps-driven developer experience. Establishes ArgoCD governance standards including multi-tenant project hierarchies, platform team RBAC models, and self-service onboarding workflows for development teams. Drives architectural decisions on ArgoCD extensibility and integration with the broader platform toolchain.
Incident Management 1
▼
Participates in on-call rotation for platform services: follows runbooks, escalates by procedure. Uses PagerDuty/OpsGenie for incident management. Documents incidents and actions in timeline. Understands severity levels and response time SLA for the platform.
Configures on-call infrastructure for the platform: PagerDuty service dependencies, escalation policies, schedule overrides. Creates and updates runbooks for common incidents. Implements automated diagnostics: auto-remediation scripts, diagnostic dashboards. Conducts incident reviews.
Designs incident management system for IDP: automated incident creation, war room automation, stakeholder communication. Implements incident retrospective process with action item tracking. Creates self-healing automation for typical platform incidents (node failures, OOM).
Defines organizational incident management strategy: on-call expectations, compensation, burnout prevention. Leads MTTR improvement through automation and tooling. Designs cross-team incident coordination for complex incidents. Creates incident readiness program.
Infrastructure as Code 4
▼
Understands basic Ansible concepts for platform component configuration and deployment automation. Follows team playbooks for provisioning platform services — container runtimes, service mesh components, monitoring agents, and load balancer configurations. Uses ansible-playbook to execute existing platform automation and reviews output for deployment issues across platform infrastructure hosts.
Independently writes Ansible playbooks and roles for platform infrastructure provisioning including Kubernetes cluster bootstrapping, certificate management, and observability stack deployment. Implements reusable platform automation modules with dynamic inventories, vault-encrypted secrets, and environment-specific variable hierarchies. Structures platform automation as self-service roles enabling development teams to provision standardized infrastructure components.
Designs Ansible automation architecture for the internal developer platform covering cluster lifecycle management, platform service deployment, and tenant onboarding workflows. Implements advanced patterns including custom Ansible collections for platform-specific resources, Tower/AWX integration for self-service platform operations, and idempotent platform upgrade playbooks with rollback capabilities. Optimizes platform automation for reliability through comprehensive testing with Molecule, infrastructure validation, and integration with platform observability systems.
Defines Ansible automation standards for platform engineering teams, establishing infrastructure-as-code practices for the internal developer platform. Creates governance frameworks for platform Ansible collections, testing requirements, and Tower/AWX workflow standards for platform operations. Conducts architecture reviews of platform automation and drives adoption of self-service infrastructure provisioning patterns across the organization.
Understands Crossplane provider model and Claims workflow. Uses existing Compositions to expose self-service infrastructure APIs to dev teams. Validates resource status and resolves basic provisioning errors with guidance.
Independently configures and manages Crossplane. Writes IaC for typical tasks. Understands networking and security basics.
Designs Crossplane-based internal developer platforms with abstracted XRDs hiding cloud complexity. Implements Composition Functions for dynamic resource templating. Enforces OPA/Kyverno policies on Claims to guarantee compliance.
Defines infrastructure strategy with Crossplane. Establishes IaC standards. Conducts architecture reviews. Optimizes FinOps.
Understands basic Pulumi IaC concepts: program structure, resource declarations, and preview/apply workflow. Deploys platform components using existing Pulumi code and Automation API examples. Follows team guidelines for stack isolation, tagging policies, and CI/CD integration patterns.
Independently configures and manages Pulumi. Writes IaC for typical tasks. Understands networking and security basics.
Designs platform infrastructure with Pulumi Automation API for developer self-service portals and internal tooling. Builds reusable multi-language component packages published to registries. Implements advanced patterns: micro-stacks, drift detection, and automated remediation pipelines.
Defines infrastructure strategy with Pulumi. Establishes IaC standards. Conducts architecture reviews. Optimizes FinOps.
Writes basic Terraform configurations for platform resources: VPC, EC2, S3. Understands state files and resource lifecycle. Uses terraform plan/apply for deploying to dev environment. Works with variables and outputs for module parameterization.
Creates Terraform modules for standardized provisioning of platform infrastructure: EKS clusters, network topology, IAM roles. Configures remote state (S3 + DynamoDB) and workspaces. Implements pre-commit hooks (tflint, tfsec) and automated plan in PRs.
Designs modular Terraform architecture for IDP: internal module registry, composition patterns, dependency management. Implements policy-as-code (Sentinel/OPA) for Terraform plan validation. Creates self-service modules for teams with automated provisioning through GitOps.
Defines organizational IaC strategy: Terraform Enterprise/Cloud, module governance, state management. Leads internal module registry development. Designs blast radius isolation through workspace strategy. Implements drift detection and automated remediation.
Infrastructure Security 1
▼
Uses HashiCorp Vault for retrieving secrets in platform services: CLI commands, KV engine. Understands authentication via tokens and AppRole. Configures Vault Agent Injector for automatic secret delivery to Kubernetes pods. Follows secret rotation best practices.
Administers Vault for the platform: configures secret engines (KV, PKI, database), auth methods (Kubernetes, OIDC). Creates policy hierarchy for multi-tenant access. Configures dynamic secrets for databases with automatic rotation. Integrates External Secrets Operator with Kubernetes.
Designs secrets management architecture for IDP: Vault HA cluster, disaster recovery, performance replication. Implements PKI infrastructure through Vault CA for mTLS between services. Creates self-service secrets management for teams through Backstage + Vault API integration.
Defines organizational secrets management strategy: Vault Enterprise features, namespaces for BU isolation, audit compliance. Leads zero-trust secrets adoption: transit encryption, tokenization. Designs DR strategy for Vault and key management governance process.
Kubernetes & Orchestration 3
▼
Uses ready-made Helm charts for deploying platform components (Prometheus, Grafana, cert-manager). Understands values.yaml and can customize deployment parameters. Works with helm install/upgrade/rollback for managing releases in dev environment.
Creates custom Helm charts for platform services with templating (helpers, named templates). Configures Helmfile for declarative management of multiple releases. Uses OCI-based registry for chart storage. Implements hooks and tests for deployment validation.
Designs library of reusable Helm charts for IDP: base microservice templates, standardized values schemas. Integrates Helm into GitOps pipeline with ArgoCD. Creates chart testing framework and automated validation (helm-unittest, ct lint) in CI.
Defines packaging and distribution strategy for internal platform: Helm library charts, umbrella charts for environments. Manages chart lifecycle: versioning, deprecation, migration. Creates self-service component catalog based on Helm for development teams.
Works with namespaces and RBAC for team isolation on the platform. Configures ResourceQuotas and LimitRanges for tenants. Understands Ingress controllers and network policies. Uses kubectl for diagnosing cluster problems.
Creates Custom Resource Definitions (CRDs) for automating platform processes. Configures Pod Security Standards and Network Policies for multi-tenant clusters. Manages stateful applications through operators (etcd, PostgreSQL). Optimizes scheduler and affinity rules.
Develops Kubernetes operators for IDP automation (Operator SDK/kubebuilder). Designs multi-tenant architecture with virtual clusters (vCluster). Implements advanced networking (Cilium, eBPF). Creates admission webhooks for platform policy enforcement.
Defines multi-cluster Kubernetes strategy for organization: federation, fleet management (Rancher/Tanzu). Leads platform API development through CRDs and controllers. Designs cluster lifecycle management with automatic upgrades and disaster recovery.
Deploys applications via Deployment, Service, ConfigMap in the platform dev cluster. Understands Pod lifecycle and ReplicaSet behavior. Uses kubectl logs/describe/exec for debugging. Configures liveness and readiness probes for platform components.
Manages production workloads on the platform: HPA, PDB, topology spread constraints. Configures persistent storage through StorageClass and PVC. Works with ServiceAccount and RBAC for service authentication. Configures resource requests/limits with QoS class awareness.
Designs Kubernetes cluster architecture for IDP: control plane HA, etcd tuning, API server optimization. Implements GitOps approach to cluster management. Creates standardized pod templates and security contexts. Automates cluster provisioning through IaC.
Defines organizational Kubernetes strategy: managed vs self-hosted, version policy, upgrade process. Leads capacity planning and cost optimization for clusters. Creates internal standards and best practices for Kubernetes deployment across all teams.
Logging 2
▼
Queries logs in Grafana Loki using basic LogQL syntax. Navigates Grafana dashboards to view application log streams. Understands label-based log filtering and basic log aggregation concepts.
Configures Loki ingestion pipelines with Promtail and structured metadata extraction. Builds Grafana dashboards combining Loki logs with Prometheus metrics for correlated observability. Sets up log-based alerting rules for platform health monitoring.
Architects Loki deployment topology for high-throughput multi-cluster log aggregation. Designs log pipeline standards including labeling conventions, retention policies, and cost optimization. Integrates Loki into the platform observability stack alongside tracing and metrics.
Adopts Grafana Loki as cost-effective logging solution for the platform: multi-tenant configuration, retention policies. Designs label strategy for optimal query performance. Integrates with Grafana for unified observability (logs + metrics + traces in single UI).
Uses structured logging (JSON) in platform services: standard fields (timestamp, level, service, trace_id). Understands the difference between structured and unstructured logs. Adds contextual information to logs for improved debuggability. Follows platform logging guidelines.
Creates structured logging standards for the platform: unified field schema, correlation IDs, request context propagation. Develops logging libraries/middleware for stack languages. Configures log-based metrics and alerts. Implements log sampling for high-throughput services.
Designs logging strategy for IDP: unified log format, automatic context enrichment through sidecar/SDK. Implements semantic conventions (OpenTelemetry Logs) for cross-service correlation. Creates developer tooling for convenient log work: CLI, Grafana dashboards, saved queries.
Defines organizational logging standards: compliance requirements (PII masking), retention policies, access control. Leads logging best practices adoption through golden paths. Designs log analytics pipeline for business insights and incident investigation.
Metrics & Monitoring 1
▼
Instruments platform services with custom metrics: request duration, queue depth, cache hit ratio. Uses Prometheus client libraries for exposing metrics. Understands naming conventions and label best practices. Creates dashboards for visualizing custom metrics.
Develops standard metrics library for the platform: RED metrics (Rate, Errors, Duration), USE metrics for infrastructure. Creates metric generator middleware for automatic collection. Configures metric-based autoscaling (KEDA, custom HPA). Optimizes cardinality.
Designs metrics strategy for IDP: business metrics pipeline, SLI/SLO automation through custom metrics. Implements metrics-as-code approach: Terraform for Grafana dashboards, alerts through GitOps. Creates self-service metrics onboarding for new services through Backstage.
Defines organizational metrics strategy: golden signals for each tier, cardinality budget, cost allocation. Leads observability standards adoption. Designs metric-driven decision framework: automated scaling, deployment decisions, capacity planning based on custom metrics.
Networking 1
▼
Understands TCP/IP, DNS, HTTP for diagnosing platform network issues. Uses curl, dig, traceroute for debugging connectivity. Configures Security Groups and NACLs in cloud infrastructure. Understands the difference between L4 and L7 load balancing for platform services.
Designs network topology for platform services: VPC peering, Transit Gateway, DNS zones. Configures Kubernetes network policies (Calico, Cilium) for tenant isolation. Implements mTLS between services. Optimizes latency through topology-aware routing.
Develops IDP network architecture: multi-VPC strategy, hybrid connectivity (VPN, Direct Connect). Implements eBPF-based networking for advanced observability and security. Designs DNS strategy for service discovery and multi-cluster communication.
Defines organizational network strategy: zero-trust architecture, network segmentation, compliance. Leads network automation adoption: NetDevOps, infrastructure-as-code for networking. Designs multi-region networking considering latency and data residency.
Release Management 1
▼
Uses feature flags (LaunchDarkly, Unleash) for controlled rollout of platform features. Creates boolean and multivariate flags. Understands targeting rules and percentage-based rollout. Participates in cleanup of stale flags following team instructions.
Integrates feature flag system into the platform: SDK configuration for microservices, server-side evaluation. Configures segmentation and A/B testing. Creates standard flag usage patterns for teams. Implements observability for feature flag impact analysis.
Designs feature flag infrastructure as part of IDP: self-hosted solution (Unleash, Flagsmith), CI/CD integration. Creates automatic flag lifecycle management. Implements feature flags for infrastructure rollout: canary config changes, gradual migration.
Defines organizational feature management strategy: governance, naming conventions, audit trail. Leads progressive delivery adoption through flags for all teams. Designs impact analytics and automatic rollback based on metrics when SLI degrades.
Serverless 2
▼
Understands serverless container platforms for developer self-service. Configures Cloud Run or Fargate task definitions with Terraform. Sets up logging, health checks, and basic auto-scaling policies.
Independently configures and manages Serverless Containers. Writes IaC for typical tasks. Understands networking and security basics.
Designs infrastructure solutions with Serverless Containers. Optimizes cost and performance. Implements best practices and security hardening.
Defines infrastructure strategy with Serverless Containers. Establishes IaC standards. Conducts architecture reviews. Optimizes FinOps.
Creates simple Lambda/Cloud Functions for automating platform tasks: webhook handlers, notifications, scheduled jobs. Configures triggers (API Gateway, CloudWatch Events). Understands cold start and execution limits. Tests functions locally via SAM/serverless.
Develops serverless platform components: event-driven processing of infrastructure events, custom resource handlers for CloudFormation/CDK. Optimizes cold starts through provisioned concurrency. Configures observability for serverless (X-Ray, structured logging).
Designs serverless architecture as part of IDP: event mesh for platform events, step functions for workflow orchestration. Creates framework for typical serverless tasks with templates and CI/CD. Implements canary deployments and traffic shifting for Lambda.
Defines organizational serverless strategy: use cases vs containers, cost model, vendor lock-in analysis. Leads serverless platform creation with self-service for teams. Designs multi-region failover and disaster recovery for serverless workloads.
Service Mesh 2
▼
Understands Envoy sidecar model and service mesh data plane concepts. Applies existing filter chains and route configurations for service-to-service communication. Monitors proxy metrics and health check endpoints under guidance.
Independently configures and manages Envoy Proxy. Writes IaC for typical tasks. Understands networking and security basics.
Designs Envoy-based API gateway layer with JWT validation, RBAC filters, and per-route rate limits. Optimizes connection pooling and upstream health check tuning for low-latency microservices. Implements Wasm extensions for custom observability and traffic shaping policies.
Defines infrastructure strategy with Envoy Proxy. Establishes IaC standards. Conducts architecture reviews. Optimizes FinOps.
Understands Istio architecture including control plane and data plane components. Uses existing Istio configurations for service discovery and load balancing. Troubleshoots basic connectivity issues in the mesh.
Independently configures and manages Istio Service Mesh. Writes IaC for typical tasks. Understands networking and security basics.
Designs self-service Istio platform abstractions for development teams. Implements canary deployments and circuit breakers via Istio traffic policies. Hardens mesh security with strict mTLS and RBAC policies.
Defines infrastructure strategy with Istio Service Mesh. Establishes IaC standards. Conducts architecture reviews. Optimizes FinOps.
System Design 2
▼
Monitors resource utilization of platform clusters: CPU, RAM, storage via Grafana dashboards. Creates basic alerts when approaching limits. Understands Kubernetes requests/limits concepts and their impact on capacity. Collects data for monthly capacity reports.
Analyzes platform resource consumption trends: historical data, seasonality, growth. Creates capacity models for Kubernetes clusters accounting for overcommit ratio. Plans scaling events ahead based on business forecasts. Optimizes bin packing through pod topology and affinity.
Designs capacity management system for IDP: automated right-sizing recommendations (VPA, Goldilocks). Implements predictive capacity planning based on historical metrics. Creates cost-capacity model per tenant. Automates cluster autoscaling (Karpenter) with SLA awareness.
Defines organizational capacity management strategy: FinOps practices, showback/chargeback model, reserved capacity vs spot. Leads quarterly capacity planning review with technical and business stakeholders. Designs multi-region capacity strategy with failover reserves.
Understands basic scaling patterns for platform services: horizontal scaling, caching, async processing. Configures HPA in Kubernetes for autoscaling by CPU/memory. Monitors performance metrics via Grafana. Participates in load testing.
Designs scalable platform components: message queues (Kafka, SQS), distributed caching (Redis Cluster). Implements rate limiting and circuit breaking for overload protection. Conducts load testing (k6, Locust) and analyzes bottlenecks. Optimizes database queries and connection pooling.
Develops IDP architecture for high load: event-driven processing, CQRS for read-heavy operations, sharding strategies. Implements platform-wide rate limiting and backpressure mechanisms. Creates performance testing framework as part of CI/CD. Designs graceful degradation for the platform.
Defines organizational scaling strategy: SLA tiers, capacity tiers, performance budgets. Leads performance engineering team. Designs multi-region architecture for low-latency globally distributed platform. Creates performance governance and review process.