Grade Calculator — DevLevelUp

Select a role to assess

Rate your skill proficiency — the system will calculate your recommended grade

Role

Skills Self-Assessment

Role: Platform Engineer

Assessed: 0 Total: 0

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.

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.

Shapes vision for next-generation CI/CD platform: AI-assisted pipelines, predictive testing, automated compliance. Defines developer experience strategy for CI/CD. Evaluates and integrates GitHub Copilot for CI/CD and Dependabot for supply chain into a unified platform.

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.

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.

Shapes DevSecOps platform strategy based on GitLab: complete SDLC, value stream analytics, AI-powered DevOps. Defines roadmap for integrating GitLab capabilities into IDP. Evaluates GitLab Duo AI for automating developer workflows at organizational scale.

Cloud Providers 1

▼

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.

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.

Shapes software supply chain security strategy at organizational level: end-to-end provenance, in-toto attestations. Researches and adopts emerging standards (VEX, CycloneDX). Advises C-level on compliance risks and investments in container security infrastructure.

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.

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.

Shapes deployment automation vision for the organization: intelligent deployment orchestration, ML-based rollback decisions. Defines deployment safety standards for critical systems. Evaluates emerging approaches to zero-downtime (progressive delivery, traffic mirroring) for platform evolution.

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.

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.

Shapes vision for intelligent release management: ML-powered canary analysis, automated experiment design. Defines confidence-based deployment strategy for the organization. Evaluates advanced techniques: shadow traffic, synthetic canary, chaos-informed releases for reliable platform.

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.

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.

Shapes edge computing strategy for the platform: edge-native applications, distributed data stores, WASM at edge. Defines architectural patterns for geo-distributed platform. Evaluates convergence of CDN, edge compute and serverless for next-gen platform.

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.

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.

Shapes vision for intelligent traffic management: ML-based routing, predictive autoscaling, self-healing infrastructure. Defines unified data plane strategy for the organization. Evaluates emerging approaches to traffic engineering for scaling the platform globally.

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.

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.

Shapes the organization's platform engineering vision with ArgoCD as the declarative delivery backbone. Drives innovation in platform-as-a-product patterns using ArgoCD extensibility — custom resource actions, ApplicationSet generators, and config management plugins. Influences CNCF platform engineering community standards and contributes to ArgoCD project governance.

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.

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.

Shapes the organization's platform automation strategy with Ansible for scalable, self-service infrastructure delivery. Drives innovation in platform automation patterns including declarative platform state management, event-driven platform healing with ansible-rulebook, and integration with Kubernetes operators for hybrid platform management. Influences platform engineering community practices through Ansible collection development and thought leadership on platform-as-a-product automation design.

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.

Defines infrastructure strategy with Crossplane. Establishes IaC standards. Conducts architecture reviews. Optimizes FinOps.

Defines infrastructure abstraction strategy through Crossplane for the entire organization: Compositions as platform API, XRDs for self-service provisioning. Designs provider architecture for multi-cloud. Integrates with IDP (Backstage) for declarative infrastructure management through UI.

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.

Defines infrastructure strategy with Pulumi. Establishes IaC standards. Conducts architecture reviews. Optimizes FinOps.

Evaluates and adopts Pulumi as an alternative to declarative IaC for complex platform scenarios: dynamic infrastructure, testing in general-purpose languages. Defines automation API strategy for self-service provisioning. Creates reusable Component Resources for infrastructure standardization.

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.

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.

Shapes long-term infrastructure abstraction strategy: Terraform + Crossplane + Pulumi, tool selection by use case. Defines architecture for self-service provisioning through API-driven IaC. Influences IaC ecosystem evolution through open-source contributions and community leadership.

Kubernetes & Orchestration 2

▼

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.

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.

Shapes architectural vision for package management on the platform: Helm vs Kustomize vs CUE, strategy for multi-cluster. Evaluates alternative approaches (Timoni, Carvel). Defines configuration management standards at organizational level for scaling IDP.

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.

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.

Shapes architectural strategy for Kubernetes platform: edge computing, serverless on K8s (Knative), WebAssembly workloads. Influences upstream Kubernetes through KEPs and community contributions. Defines 3-5 year roadmap for organizational container platform evolution.

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.

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.

Shapes cloud networking vision: eBPF revolution, programmable data plane, intent-based networking. Defines network security strategy at organizational level. Evaluates emerging technologies (DPDK, SmartNIC) for high-performance platform networking.

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.

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.

Shapes vision for progressive delivery platform: feature flags + canary + observability as unified release management. Defines experimentation platform strategy. Evaluates AI-driven feature rollout with automated impact analysis and decision-making.

Serverless 2

▼

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

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.

Shapes vision for event-driven platform: serverless + event mesh + CQRS for scalable distributed systems. Defines portable serverless strategy (Knative, WASI) to avoid vendor lock-in. Evaluates WebAssembly as next-generation serverless runtime.

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.

Defines infrastructure strategy with Envoy Proxy. Establishes IaC standards. Conducts architecture reviews. Optimizes FinOps.

Defines service mesh and API gateway strategy based on Envoy for the platform: xDS API, custom filters (Lua/WASM), rate limiting. Designs traffic management architecture for multi-cluster. Evaluates Envoy Gateway as ingress controller replacement for unifying the platform data plane.

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.

Defines infrastructure strategy with Istio Service Mesh. Establishes IaC standards. Conducts architecture reviews. Optimizes FinOps.

Shapes service mesh strategy for the organization: Istio ambient mode vs sidecar, multi-cluster mesh federation. Designs zero-trust networking through mTLS and authorization policies. Defines traffic management strategy: canary, mirroring, fault injection for improving platform reliability.

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.

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.

Shapes sustainable capacity strategy for the platform: ML-driven forecasting, autonomous scaling, carbon-aware computing. Defines TCO model for on-prem vs cloud vs hybrid. Advises executives on capital planning for infrastructure investments over 3-5 year horizon.

Understands RPO/RTO metrics for platform services. Participates in DR drills following runbooks: verifies backup operability, tests restore procedures. Configures basic backup policies (Velero for K8s, AWS Backup). Documents DR testing results.

Configures DR infrastructure for the platform: Velero backup schedules, cross-region S3 replication, database replicas. Creates automated DR runbooks for key services. Conducts quarterly DR drills and analyzes gaps. Configures monitoring for RPO compliance.

Defines organizational DR strategy: tiered RPO/RTO by service criticality, budget allocation, compliance requirements. Leads game days and tabletop exercises for DR plans. Designs organizational DR governance with regular review and improvement cycles.

Shapes business continuity strategy for the platform: active-active multi-region, cell-based architecture for blast radius isolation. Defines architectural patterns for resilient distributed systems. Advises board on risk management and compliance for mission-critical platform.

Additional skills (optional) 39

These skills do not affect the main grade but show the breadth of your profile.

AI Coding Assistants

▼

Uses Cursor IDE for developing platform components: AI-assisted code completion for Terraform, Kubernetes YAML, Go. Applies Chat function for understanding complex configurations. Generates boilerplate code for Helm charts and CI/CD pipelines with AI.

Configures Cursor IDE for platform engineering: custom rules for IaC patterns, context from infrastructure documentation. Uses Composer for refactoring Terraform modules and Kubernetes manifests. Creates workspace settings for typical platform team tasks.

Defines AI-assisted development strategy for platform team: best practices, security guidelines for AI-generated IaC. Creates organizational .cursorrules for standardizing AI-assisted development. Evaluates productivity impact and builds training program for teams.

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.

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

▼

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.

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

▼

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.

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.

Understands the fundamentals of Data Structures at a basic level. Applies simple concepts in work tasks using Go/Python/HCL. Follows recommendations from senior developers when solving problems.

Independently selects appropriate data structures for platform services: API schema definitions, service catalog data models, resource quota tracking structures. Understands trade-offs between configuration data format choices for platform extensibility and developer experience.

Applies data structure knowledge for designing platform components: B-tree for storage engine, bloom filters for cache, CRDT for distributed state. Leads optimal data structure selection for high-performance platform services considering memory and CPU trade-offs.

API Management

▼

Application Security

▼

Caching

▼

Clean Code & Refactoring

▼

Understands the fundamentals of Code Quality & Refactoring at a basic level. Applies simple concepts in work tasks using Go/Python/HCL. Follows recommendations from senior developers when solving problems.

Independently applies code quality practices in platform development. Writes clean SDK and CLI code with proper API versioning and backward compatibility. Understands trade-offs between platform flexibility and developer experience simplicity. Reviews platform code for documentation coverage, error message clarity, and extension point design.

Defines code quality standards for platform services: linting rules, testing requirements, documentation standards. Implements automated quality gates in CI/CD: coverage thresholds, static analysis, dependency scanning. Creates quality-focused culture through code review practices and pair programming.

Cloud Providers

▼

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.

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.

Shapes cloud strategy at C-level: multi-cloud vs AWS-first, Enterprise Discount Program negotiation. Defines architectural principles for cloud platform over 3-5 year horizon. Evaluates emerging AWS services for organizational strategic advantage.

Code Review

▼

Participates in code review of platform changes: checks Terraform plans, Kubernetes manifests, CI/CD configs. Leaves constructive comments on readability and best practices. Understands the importance of code review for infrastructure-as-code. Learns from senior engineer feedback.

Conducts thorough code reviews for platform components: security implications of IaC changes, blast radius assessment, backward compatibility. Creates review checklists for typical changes (new service, infra change). Configures automated checks (tflint, kubeval) as pre-review gates.

Establishes organizational code review culture: cross-team reviews for shared platforms, architecture review for major changes. Leads CODEOWNERS and required approvals adoption for critical infrastructure. Designs review workflows balancing velocity and quality.

Concurrency & Parallelism

▼

Containerization

▼

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.

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.

Shapes industry-level approach to container security and supply chain integrity for the platform. Develops strategy for transitioning to next-generation container runtimes (kata, gVisor). Defines architectural decisions for multi-cloud container orchestration and OCI compatibility standards.

Distributed Tracing

▼

Configures OpenTelemetry SDK in platform services: auto-instrumentation for traces and metrics. Deploys OTel Collector for receiving and exporting telemetry. Understands traces, spans, attributes and their relationships. Views traces in Jaeger/Tempo for request debugging.

Implements OpenTelemetry as the platform observability standard: custom instrumentation, context propagation, sampling strategies. Configures OTel Collector pipeline: receivers, processors, exporters for telemetry routing. Creates OTel SDK wrapper for standardized instrumentation.

Defines OpenTelemetry-based observability strategy: vendor-neutral collection, backend strategy, cost optimization. Leads organizational migration to OTel. Designs observability data pipeline with routing, sampling, and aggregation. Creates OTel maturity roadmap.

Git & Workflows

▼

Knows Git basics for working with platform repositories: branch, merge, rebase, resolve conflicts. Follows the team's Git Flow or trunk-based development model. Understands .gitignore for IaC files (state, secrets). Creates meaningful commits for infrastructure changes.

Uses advanced Git for managing platform code: monorepo strategies (sparse checkout, worktrees), git hooks for pre-commit validation. Configures branch protection rules and CODEOWNERS for IaC repositories. Creates Git strategy for multi-environment configurations.

Defines organizational Git strategy: repository structure, branching model, code ownership for all teams. Leads migration between Git platforms (GitLab/GitHub). Designs inner source model with cross-team contribution workflows. Creates Git governance and audit process.

GitOps

▼

Understands GitOps as a platform pattern: knows how the platform can provide GitOps-as-a-service for development teams. Can work with ArgoCD/Flux at the Application resource creation level.

Builds GitOps platform: configures ArgoCD in multi-tenant mode with per-team RBAC, creates ApplicationSets for automated onboarding, implements template repositories for standardized deployment configs. Configures notification system for sync failures.

Standardizes GitOps at platform level: defines platform team's GitOps workflow for infrastructure changes, creates golden path templates, designs policy-as-code enforcement via OPA/Kyverno integrated into GitOps. Ensures platform self-healing through GitOps reconciliation.

Shapes enterprise platform strategy through GitOps: designs platform-of-platforms architecture with GitOps at core, defines standards for cross-team infrastructure management. Influences GitOps ecosystem: contributions to ArgoCD, Flux, Crossplane for platform engineering use cases.

GraphQL

▼

Incident Management

▼

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.

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 Security

▼

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.

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.

Integration Testing

▼

Kubernetes & Orchestration

▼

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.

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.

Shapes long-term vision for container orchestration: Kubernetes vs alternatives (Nomad, ECS), hybrid approaches. Defines architectural principles for scaling K8s to hundreds of microservices. Influences industry standards through open-source contributions.

Logging

▼

Uses Kibana for searching platform service logs: KQL queries, filters, time ranges. Understands index structure and field mapping. Configures Filebeat/Fluentd for collecting logs from Kubernetes pods. Creates basic Kibana dashboards for platform monitoring.

Administers ELK cluster for the platform: configures ILM policies, hot-warm-cold architecture, sharding. Creates ingest pipelines for log parsing and enrichment. Configures cross-cluster search for multi-environment logging. Optimizes storage through data streams and rollover.

Defines centralized logging strategy: ELK vs alternatives (Loki, Datadog), cost-performance balance. Leads capacity planning for logging infrastructure. Designs compliance-compliant log retention with audit trail. Creates observability standards and SLA for log platform.

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.

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

Defines logging strategy: Loki vs ELK vs managed solutions for various platform use cases. Designs Loki at scale: microservices mode, S3 backend, caching. Shapes vision for cost-efficient observability data platform with tiered storage.

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.

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

▼

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.

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.

Shapes vision for data-driven platform: custom metrics + ML for predictive operations, anomaly detection, root cause analysis. Defines metric democratization strategy for business and tech teams. Evaluates real-time streaming analytics for next-gen observability platform.

Configures Prometheus scraping for platform services: ServiceMonitor, PodMonitor in Kubernetes. Creates basic Grafana dashboards for infrastructure monitoring. Understands counter, gauge, histogram metric types. Sets up simple alerting rules through Alertmanager.

Administers Prometheus stack for the platform: Thanos/Cortex for long-term storage, federation for multi-cluster. Creates recording rules for query optimization. Develops standard dashboard templates (Jsonnet/Grafonnet). Configures Alertmanager routing and escalation.

Defines metrics platform strategy: build vs buy, cardinality management, cost optimization. Leads observability-as-code adoption across all teams. Designs SLO-based monitoring with automated alerting. Creates observability maturity model for the organization.

OOP & Design Patterns

▼

Understands the fundamentals of Design Patterns at a basic level. Applies simple concepts in work tasks using Go/Python/HCL. Follows recommendations from senior developers when solving problems.

Independently applies design patterns for platform engineering: strategy pattern for pluggable infrastructure providers, template method for standardized deployment pipelines, adapter for multi-cloud service abstraction, observer for platform event propagation. Explains pattern trade-offs for platform API design.

Implements architectural patterns for platform services: Operator pattern for K8s, Sidecar/Ambassador for service mesh, Circuit Breaker for resilience. Leads design pattern standardization through golden path templates. Conducts pattern-focused design reviews.

Prompt Engineering

▼

Relational Databases

▼

REST API

▼

Specialized Testing

▼

Understands chaos engineering in platform context: knows the platform should provide chaos testing tools, understands how Kubernetes primitives (PodDisruptionBudget) relate to chaos resilience.

Integrates chaos engineering into the platform: installs and configures Chaos Mesh/Litmus as platform service, creates experiment templates for developer self-service. Ensures isolation: chaos experiments don't escape target namespace.

Standardizes chaos engineering at platform level: designs automated resilience scoring infrastructure, creates chaos experiment marketplace for reuse. Defines platform-level chaos: testing platform components themselves (control plane, etcd, ingress).

System Design

▼

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.

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.

Understands basic platform system design principles: client-server, REST API, databases. Creates simple architecture diagrams for platform components. Understands CAP theorem and trade-offs when choosing storage. Participates in design review meetings.

Designs individual platform components: API design, caching strategy, message-driven architectures. Analyzes trade-offs when choosing technologies. Creates ADRs (Architecture Decision Records) for platform decisions. Conducts design reviews for new services.

Defines architectural standards and principles for the platform: API-first design, modular architecture, domain boundaries. Leads Architecture Guild and review process. Creates Technology Radar for the organization. Designs evolutionary architecture for long-term IDP development.

Type Systems

▼

Unit Testing

▼