These skills do not affect the main grade but show the breadth of your profile.
AI Coding Assistants
▼
Uses ChatGPT and Claude for generating Terraform, Ansible and Dockerfile templates. Formulates queries for finding solutions to typical infrastructure tasks and debugging configurations.
Applies AI assistants for optimizing infrastructure configurations, analyzing cost reports and troubleshooting. Creates prompts for generating IaC modules following best practices and compliance requirements.
Establishes AI usage standards for the infrastructure team, including AI recommendation verification for production changes. Defines AI trust boundaries for infrastructure decisions of varying criticality levels.
Uses Cursor IDE for editing infrastructure files: Terraform, YAML, Ansible with AI suggestions. Applies basic search and navigation in IaC code projects within the working environment.
Configures Cursor IDE for infrastructure development with extensions for Terraform, Kubernetes and Ansible. Uses AI features for IaC module generation and infrastructure configuration refactoring.
Standardizes Cursor IDE configuration for the infrastructure team with templates, snippets and extensions. Defines best practices for AI usage with infrastructure code considering security.
Uses GitHub Copilot for accelerating infrastructure code writing: auto-completion of Terraform resources, generating bash scripts for automation, suggestions for Ansible YAML configurations. Verifies AI suggestions for cloud resource parameter correctness and configuration security.
Effectively uses Copilot for infrastructure tasks: generating Terraform modules from comments, creating Ansible playbooks from descriptions, auto-completing CI/CD pipelines. Uses Copilot Chat for explaining complex networking configurations and debugging Kubernetes manifests, critically evaluating suggestions.
Defines AI assistant usage standards for the infrastructure team: guidelines for Copilot with IaC code, review rules for AI-generated Terraform modules on security compliance. Implements custom instructions for infrastructure context and trains team on effective prompt patterns for DevOps tasks.
Alerting & On-Call
▼
Understands the difference between SLI, SLO and SLA in infrastructure context: SLI as specific metrics (uptime, latency p99, error rate), SLO as target values, SLA as contractual obligations. Can read SLO dashboards, understands error budget concept and knows how infrastructure issues affect SLI.
Configures SLI/SLO monitoring for infrastructure services: defining key SLIs (availability, latency, throughput), implementing SLOs through Prometheus recording rules. Configures burn rate alerts for early warning, creates SLO dashboards with error budget tracking and sets up multi-window alerting.
Defines SLO standards for all infrastructure: standard SLIs for each component class (compute, storage, network, DB), SLO negotiation process with teams. Implements SLO-driven prioritization for engineering work, reviews team SLOs and coordinates error budget policy with product management.
Shapes SLO-driven infrastructure strategy for the company: framework for defining business-critical SLIs, SLA strategy for external and internal customers, SLO integration with FinOps. Defines SLO approach for emerging technologies (AI/ML inference, edge), C-level reporting standards and SLO correlation with business metrics.
Algorithms & Data Structures
▼
Understands the fundamentals of Algorithms & Complexity at a basic level. Applies simple concepts in work tasks using HCL/Python. Follows recommendations from senior developers when solving problems.
Independently applies algorithmic thinking in infrastructure: evaluates resource allocation algorithms, understands network routing optimization, selects provisioning strategies considering dependency ordering. Analyzes complexity of automation workflows and infrastructure scaling operations.
Reviews algorithmic solutions in infrastructure tools: analyzing provisioning script complexity, optimizing service dependency graph traversal. Evaluates deployment planning and container placement algorithms, implements automation performance standards for fleets of hundreds of servers.
Understands the fundamentals of Data Structures at a basic level. Applies simple concepts in work tasks using HCL/Python. Follows recommendations from senior developers when solving problems.
Independently selects appropriate data structures for infrastructure management: inventory data models, configuration hierarchies for host/service management, network topology representations. Understands trade-offs between flat vs hierarchical configuration structures for automation.
Standardizes infrastructure data modeling approaches: host inventory files, service YAML configs, DNS record trees. Reviews data structure choices in IaC modules — Terraform resource mappings, nested Ansible variables, Helm chart configuration hierarchies.
API Management
▼
Reads and understands API documentation of cloud providers and infrastructure tools. Documents simple automation scripts with parameter descriptions and launch examples.
Creates documentation for infrastructure modules: describing Terraform inputs/outputs, Ansible variables. Documents internal platform service APIs with usage examples for DevOps teams.
Defines infrastructure documentation strategy for different audiences: developers, ops, security. Organizes documentation-as-code process with auto-generation from Terraform and Ansible.
Application Security
▼
Knows basic OWASP Top 10 categories in infrastructure context: injection attacks through config templates, sensitive data exposure in logs, server misconfiguration. Applies security checklists when configuring nginx/Apache web servers and understands security headers.
Applies OWASP recommendations when configuring infrastructure: WAF rule configuration in CloudFront/Cloudflare, web server hardening per CIS benchmarks, CSP and HSTS header configuration. Automates security scanning of infrastructure endpoints through OWASP ZAP in CI pipelines.
Defines application security standards at infrastructure level: WAF policies for all public endpoints, security header standards, vulnerability response process. Reviews team security configurations and implements continuous security testing in infrastructure pipelines.
Knows basic secure coding principles: input validation, secrets management. Applies these principles when writing infrastructure scripts and never hardcodes credentials.
Implements secure secrets management through Vault and AWS Secrets Manager in infrastructure code. Configures encryption at rest and in transit for all infrastructure components and data.
Defines security baseline for organizational infrastructure with enforcement through policy-as-code. Designs security guardrails for self-service platform, preventing insecure configurations by default.
CI/CD
▼
Understands CI/CD concepts and basic GitHub Actions workflow syntax. Can run linters and simple infrastructure code checks in pipeline on each pull request.
Configures GitHub Actions for automatic Terraform module testing, Ansible playbook validation. Implements multi-stage pipelines with plan, apply and post-deploy verification for infrastructure changes.
Defines CI/CD standards for organizational infrastructure changes with approval workflows and environment protection. Designs GitOps processes with automatic reconciliation and rollback for infrastructure.
Clean Code & Refactoring
▼
Understands the fundamentals of Code Quality & Refactoring at a basic level. Applies simple concepts in work tasks using HCL/Python. Follows recommendations from senior developers when solving problems.
Independently applies code quality practices in infrastructure automation. Writes clean Ansible playbooks and Terraform modules with proper variable scoping. Understands trade-offs between infrastructure abstraction and operational transparency. Reviews provisioning code for idempotency, rollback safety, and documentation completeness.
Implements infrastructure code quality practices: tflint and checkov for Terraform, ansible-lint for playbooks, shellcheck for bash scripts. Configures CI pipelines with automatic IaC validation, defines code review standards for infrastructure modules and merge policies.
Cloud Providers
▼
Works with basic AWS services as an infrastructure engineer: EC2 for virtual machines, S3 for storage, VPC for basic networking. Uses AWS CLI for routine operations, understands IAM roles and policies, can view CloudWatch metrics and logs for diagnostics.
Manages AWS infrastructure through IaC: designing VPCs with public/private subnets, configuring ALB/NLB, managing EKS clusters. Configures RDS with Multi-AZ, sets up CloudWatch alarms and SNS notifications, uses Systems Manager for EC2 instance fleet management.
Defines AWS infrastructure standards for the organization: landing zone architecture, account vending through Control Tower, tagging standards for FinOps. Reviews team AWS architectures against Well-Architected Framework, implements self-service through Service Catalog and defines SLO for AWS services.
Code Review
▼
Participates in infrastructure code reviews as both reviewer and author: checks Terraform configurations for basic errors, reads senior engineers' comments for learning. Can describe changes in PRs (which resources are created/modified) and attaches terraform plan output for clarity.
Conducts quality code reviews for IaC: reviewing Terraform modules for security best practices, validating Ansible playbooks for idempotency, analyzing Kubernetes manifests for resource limits. Pays attention to drift risk, checks backward compatibility of changes and evaluates modification blast radius.
Defines code review standards for the infrastructure team: checklists for different change types (network, compute, security), review time SLA, escalation process for critical changes. Implements automated review through Danger.js and custom bots, coordinates cross-team review for shared infrastructure.
Collaboration Tools
▼
Documents infrastructure components in docs-as-code format: README.md for Terraform modules with input/output descriptions, basic runbooks in Markdown for routine operations. Uses terraform-docs for module documentation auto-generation and keeps records of infrastructure decisions.
Creates comprehensive infrastructure documentation as code: ADR (Architecture Decision Records) for infrastructure decisions, runbooks with automatic CI validation. Generates network diagrams from Terraform through inframap, maintains inventory documentation and configures automatic publishing through MkDocs.
Defines infrastructure documentation standards for the organization: mandatory sections for each Terraform module, runbook and playbook templates, ADR standards. Implements docs-as-code pipeline with review process, reviews team documentation for completeness and coordinates on-call handbook creation.
Shapes knowledge management strategy for company infrastructure: Internal Developer Portal architecture with auto-generated documentation, Backstage integration with IaC repositories. Defines technical writing standards for infrastructure, AI-assisted documentation roadmap and documentation coverage metrics for compliance.
Concurrency & Parallelism
▼
Understands the fundamentals of Async Programming at a basic level. Applies simple concepts in work tasks using HCL/Python. Follows recommendations from senior developers when solving problems.
Independently applies async programming in infrastructure automation: concurrent host management operations, async configuration deployment, non-blocking monitoring and health checks. Understands trade-offs between parallel and sequential infrastructure operations.
Implements asynchronous execution patterns in infrastructure automation: parallel deployment to server groups, concurrent health checks, non-blocking metrics collection. Standardizes timeout handling and retry strategies for cloud API operations that may take minutes.
Understands parallelism and multithreading concepts in infrastructure tool context. Knows how concurrent access affects Terraform state files and deployment processes.
Implements parallel infrastructure task execution: concurrent server provisioning, parallel health checks. Manages concurrency when working with shared state and distributed locks.
Defines parallel infrastructure management patterns for the organization: concurrent deployments, rolling updates. Designs distributed task execution architecture for scaling infrastructure operations.
Containerization
▼
Works with Docker at basic infrastructure engineer level: building images for infrastructure utilities, running containers with proper volume mounts, configuring docker-compose for local environment. Understands layered filesystem, layer caching and basic isolation principles.
Configures Docker infrastructure for production: optimizing multi-stage builds, configuring private registry (Harbor, ECR), managing container resources through cgroups. Automates CI/CD for images, implements vulnerability scanning through Trivy and configures garbage collection for registry.
Defines containerization standards for the organization: base image policies with automatic updates, scanning pipelines, tagging strategies. Reviews team Dockerfiles for best practices compliance, manages registry infrastructure with geo-replication and retention policies.
Database Optimization
▼
Understands basic database indexing principles and their impact on performance. Can create indexes within infrastructure migrations and monitor their usage.
Automates index management through IaC: creation, monitoring and optimization for managed databases. Configures alerts for slow queries and missing indexes in RDS and Aurora instances.
Defines database performance management standards at infrastructure level, including auto-scaling and read replicas. Designs observability solutions for monitoring index efficiency at scale.
Git & Workflows
▼
Uses Git for basic infrastructure code management: cloning repositories with Terraform modules, creating branches for configuration changes, commit and push. Understands .gitignore for excluding terraform.tfstate and secrets, can resolve simple merge conflicts in YAML files.
Applies advanced Git practices in IaC repositories: branching strategy for Terraform modules, cherry-pick for production configuration hotfixes, git bisect for finding regressions. Configures pre-commit hooks for terraform fmt, tflint and detect-secrets, manages git submodules for shared modules.
Defines Git standards for the infrastructure organization: unified branching strategy for IaC repositories, commit message standards for automated changelog, protected branch policies. Implements GitOps approach (ArgoCD, Flux) for Kubernetes and Terraform, reviews team git workflows and defines disaster recovery for git repositories.
GraphQL
▼
Understands basics of GraphQL as an interface for infrastructure management APIs. Reads GraphQL queries for resource provisioning and monitoring dashboards. Follows team conventions for infrastructure-as-code tool GraphQL API integrations.
Designs GraphQL API for internal infrastructure management platform: resource queries, deployment status. Implements resolvers with integration to cloud APIs and monitoring systems.
Defines GraphQL API architecture for organizational platform services with federation and schema governance. Designs unified API for managing multi-cloud infrastructure through a single GraphQL endpoint.
Infrastructure Security
▼
Understands basic cloud security principles: IAM users and roles, principle of least privilege, MFA for console access. Knows why security groups and NACLs are needed, can verify S3 bucket public accessibility and follows basic AWS/GCP security recommendations.
Configures cloud security through IaC: IAM policies with conditions and boundaries, SCPs for Organization, encryption at rest through KMS. Configures CloudTrail for auditing, AWS Config Rules for compliance checks, sets up VPC Flow Logs for network traffic monitoring.
Defines cloud security standards for the organization: baseline security controls for each account type, IAM role standards, data encryption policies. Reviews team security architectures, implements security guardrails through SCPs and Terraform modules, defines SLO for vulnerability time-to-remediate.
Shapes company cloud security strategy: Security Operations Center architecture for cloud, compliance framework (SOC2, ISO27001, PCI DSS), vendor risk management. Defines roadmap for CNAPP, zero-trust architecture and cloud-native SIEM, coordinates with auditors and regulators.
Integration Testing
▼
Understands the role of integration testing in verifying infrastructure component interactions. Writes simple tests for checking network connectivity and service availability after deployment.
Creates integration tests for infrastructure: DNS resolution verification, firewall rules, load balancer routing. Uses InSpec and Goss for server configuration validation after provisioning.
Defines infrastructure integration testing strategy including game-day exercises and disaster recovery tests. Establishes pre-production validation and automated rollback standards when issues are detected.
Kubernetes & Orchestration
▼
Performs basic Kubernetes operations as an infrastructure engineer: deploying applications via kubectl, viewing logs and pod statuses, basic namespace navigation. Understands core resources — Pod, Deployment, Service, ConfigMap — and can diagnose CrashLoopBackOff and ImagePullError.
Administers Kubernetes clusters: configuring Ingress controllers (nginx, traefik), setting up RBAC and NetworkPolicy, managing StorageClass and PersistentVolume. Automates deployment through Helm, configures resource requests/limits and HPA, monitors cluster health through metrics-server.
Defines Kubernetes platform standards for the organization: multi-tenant cluster architecture, namespace policies, deployment standards through GitOps. Reviews team Kubernetes manifests, designs self-service abstractions on top of K8s and defines SLO for control plane and workload availability.
Logging
▼
Works with structured logging in infrastructure context: reading JSON logs through jq, basic log navigation in Kibana/Grafana Loki, filtering by severity and service name. Understands the difference between syslog, journald and application logs, can find errors in infrastructure service logs.
Configures centralized logging for infrastructure: deploying Fluentd/Fluent Bit for log collection, configuring processing pipelines (parsing, enrichment, routing). Automates ELK/Loki deployment through Helm, configures retention policies and indexing for efficient search across millions of records.
Defines logging standards for the organization: unified structured log format, mandatory fields (trace_id, service, environment), retention policies by data class. Reviews team logging configurations, designs self-service log access and defines SLO for log ingestion latency and availability.
Message Queues & Event Streaming
▼
Uses Apache Kafka at a basic level in Terraform/Pulumi. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
Independently implements tasks with Apache Kafka in Terraform/Pulumi. Understands internals and optimizes performance. Writes tests with Terratest.
Designs Kafka infrastructure as a platform service for development teams: cluster deployment standards, retention policies, authorization schemas through ACL. Implements GitOps approach to Kafka topic management and defines SLO for broker throughput and latency.
Defines event-streaming infrastructure strategy at company level: choosing between Kafka, Pulsar, Redpanda, multi-region replication, capacity planning. Designs fault-tolerant cluster architecture, DR scenarios for messaging infrastructure and monitoring standards for dozens of clusters.
Metrics & Monitoring
▼
Uses Prometheus and Grafana for basic infrastructure monitoring: viewing standard dashboards (node-exporter, kube-state-metrics), executing simple PromQL queries (rate, sum). Understands Prometheus data model (metrics, labels, timestamps) and can find issues through existing alerts.
Administers Prometheus stack for infrastructure monitoring: deployment through kube-prometheus-stack, configuring ServiceMonitor for target auto-discovery, creating Grafana dashboards. Writes intermediate PromQL queries (histogram_quantile, absent), configures alerting rules and Alertmanager receivers.
Defines monitoring standards for the organization: mandatory metrics (RED/USE methods), standard dashboards for each service type, alert creation process with runbooks. Implements Grafana-as-a-service for self-service monitoring, reviews team alerting rules and defines SLO for monitoring infrastructure.
Networking
▼
Understands basic networking concepts for infrastructure management — IP addressing, VLAN configuration, load balancer setup, and firewall rule management. Follows team guidelines for provisioning network infrastructure and troubleshooting connectivity between data center and cloud resources.
Designs network infrastructure for common tasks: VPCs with subnets and route tables, security groups and NACLs, VPN connections for hybrid cloud. Configures DNS zones through Route53/CloudDNS, sets up NAT Gateway and understands BGP for interconnect connections.
Defines organizational infrastructure network standards: IP addressing and CIDR planning for hundreds of VPCs, firewall rule standards, DNS naming policies. Reviews team network architectures, designs network traffic observability and defines SLO for network availability.
Shapes organizational network strategy: global network architecture across multiple regions and clouds, backbone design, IPv6 migration strategy. Makes decisions on SD-WAN, SASE architecture and zero-trust networking, defines roadmap for network automation through intent-based approaches.
OOP & Design Patterns
▼
Knows main design patterns and understands their application in infrastructure context. Uses Template Method and Factory patterns when writing infrastructure automation scripts.
Applies Builder pattern for constructing complex infrastructure configurations and Adapter for cloud integrations. Uses Strategy for deployment strategy selection: blue-green, canary, rolling update.
Defines organizational infrastructure pattern catalog: immutable infrastructure, cattle vs pets, twelve-factor. Makes architectural decisions based on proven patterns for common tasks.
Understands basic OOP principles and their application in infrastructure code. Uses classes and inheritance when writing Python automation utilities for infrastructure management.
Applies SOLID principles when developing infrastructure tools: modular providers, resource abstractions. Uses OOP patterns for creating reusable automation components.
Defines architectural standards for organizational infrastructure code with emphasis on modularity and reusability. Reviews infrastructure tool design for clean architecture principles compliance.
Prompt Engineering
▼
Formulates basic prompts for getting help with infrastructure tasks from AI assistants. Understands the importance of specifying context: cloud provider, tool version and environment constraints.
Creates structured prompts for IaC code generation, incident analysis and cloud cost optimization. Uses chain-of-thought for complex network topology design and DR planning tasks.
Establishes prompt engineering standards for the infrastructure team focused on security and compliance. Defines validation process for AI-generated infrastructure solutions before production deployment.
Relational Databases
▼
Performs basic PostgreSQL operations as an infrastructure engineer: server installation through package managers, configuring pg_hba.conf for network access, creating users and databases. Can run backups through pg_dump and monitor state through pg_stat_activity.
Automates PostgreSQL deployment through Ansible roles: configuring postgresql.conf for performance, setting up streaming replication, automatic backups through pgBackRest. Monitors metrics through postgres_exporter in Prometheus, configures alerts on replication lag and connection pool.
Designs PostgreSQL as a platform service for developers: self-service instance creation through Terraform, configuration standards for different workload profiles, update automation. Defines SLO for database availability and performance, reviews team architectural decisions.
REST API
▼
Uses REST APIs of cloud providers and infrastructure services at a basic level: AWS API calls through CLI, Terraform Cloud API requests, Vault API for retrieving secrets. Understands HTTP methods, response codes and token authentication in infrastructure context.
Develops integration scripts with infrastructure service REST APIs: automation through Kubernetes API, programmatic DNS management through Cloudflare/Route53 API, monitoring API integration. Implements retry logic, pagination and rate-limit handling for bulk operations.
Defines API standards for internal platform services: unified error format, naming conventions, versioning, authentication through service accounts. Reviews API interfaces of team infrastructure tools and ensures compatibility with corporate API gateway.
Specialized Testing
▼
Understands infrastructure-level chaos: knows that server, disk, network, and DNS failures can be tested. Understands how redundancy (multi-AZ, replication) protects against infrastructure failures. Participates in disaster recovery testing.
Conducts infrastructure chaos experiments: tests database failover (RDS failover, Redis sentinel), network partition between AZs, disk failure scenarios. Uses AWS Fault Injection Simulator or terraform-based fault injection for cloud infrastructure.
Defines infrastructure resilience strategy: designs multi-region failover architecture validated through chaos, creates infrastructure chaos suite for continuous verification. Standardizes DR procedures and ensures RTO/RPO compliance through regular testing.
System Design
▼
Understands basic system design principles and infrastructure components: DNS, load balancers, CDN. Knows the difference between horizontal and vertical scaling and use cases for each.
Designs infrastructure for common architectures: three-tier applications, microservices, event-driven systems. Considers availability, performance and cost requirements when selecting components.
Defines infrastructure architecture standards for different service criticality levels. Creates reference architectures and landing zones for fast onboarding of new product teams.
Type Systems
▼
Understands type safety concept and its role in preventing errors in infrastructure code. Uses basic types in Terraform variables and TypeScript for CDK configurations.
Applies strict typing in infrastructure code: Terraform variable types, Pulumi with TypeScript, CDK constructs. Creates typed interfaces for infrastructure modules to prevent configuration errors.
Defines type safety standards for organizational infrastructure code with automatic verification in CI/CD. Designs type-safe API for internal platform with compile-time configuration checks.
Unit Testing
▼
Writes basic unit tests for infrastructure scripts and automation utilities. Understands the importance of testing for preventing errors in server configurations and network settings.
Creates unit tests for Terraform modules, Ansible roles and infrastructure Lambda functions using mocks. Uses terratest and Molecule for automatic IaC component verification in CI/CD.
Defines infrastructure testing strategy for the organization: unit, integration and acceptance tests for IaC. Establishes quality gate standards for infrastructure changes with automatic verification in pipeline.