DevOps & Automation terms

Study this subject with thinQcards™

• .dockerignoreA file that excludes paths from the Docker build context sent to the builder.Foundational
• .gitignoreA file listing patterns of files and directories Git should not track, such as build outputs and secrets.Foundational
• A/B TestingExperimentation that serves different variants to user groups and compares business metrics to decide which performs better.Foundational
• ActionA reusable unit of code for GitHub Actions workflows, implemented as JavaScript, a Docker container, or a composite of steps.Intermediate
• Admission ControllerA Kubernetes API server plugin that intercepts requests after authentication and authorization to validate or mutate objects before persistence.Advanced
• Alert FatigueDesensitization of responders caused by too many, too noisy, or non-actionable alerts, leading to missed real incidents.Foundational
• AlertmanagerThe Prometheus component that deduplicates, groups, routes, silences, and inhibits alerts and sends notifications.Intermediate
• AnnotationNon-identifying key-value metadata on Kubernetes objects used by tools and controllers, not for selection.Foundational
• AnsibleRed Hat's agentless, open-source automation tool that configures systems and network devices using YAML playbooks over SSH, WinRM, or APIs.Foundational
• Ansible Ad-Hoc CommandA one-off Ansible command run from the CLI to execute a single module against hosts without writing a playbook.Foundational
• Ansible Automation Platform (AAP)Red Hat's enterprise automation platform providing automation controller (formerly AWX/Tower), execution environments, Automation Hub, and Event-Driven Ansible.Advanced
• Ansible CollectionA distribution format bundling Ansible modules, plugins, roles, and playbooks under a namespace, shared via Ansible Galaxy or Automation Hub.Intermediate
• Ansible FactsSystem information that Ansible gathers from managed hosts at the start of a play and stores as variables.Intermediate
• Ansible HandlerAn Ansible task that runs only when notified by another task that reported a change, typically to restart services.Intermediate
• Ansible InventoryThe list of managed hosts and groups, with variables, that Ansible targets, written in INI or YAML or generated dynamically.Foundational
• Ansible ModuleA discrete unit of code that Ansible executes to perform a task, such as installing packages or configuring interfaces.Intermediate
• Ansible PlaybookA YAML file containing one or more plays that map groups of hosts to ordered tasks executed with Ansible modules.Foundational
• Ansible RoleA standardized directory structure that packages tasks, handlers, variables, templates, and files for reuse across playbooks.Intermediate
• Ansible VaultAn Ansible feature that encrypts sensitive variables and files with AES-256 so they can be stored in version control.Intermediate
• API Authentication MethodsWays clients prove identity to APIs, including HTTP Basic, API keys, bearer tokens, OAuth 2.0, and mutual TLS.Foundational
• API PaginationSplitting large API result sets into pages retrieved by successive requests using offsets, page numbers, or cursors.Intermediate
• API Rate LimitingRestricting how many API requests a client can make in a time period to protect service availability.Intermediate
• Application Performance Monitoring (APM)Tooling that instruments applications to track transaction performance, errors, dependencies, and resource usage.Foundational
• Application Programming Interface (API)A defined contract that lets software components communicate by exposing operations, data formats, and rules for requests and responses.Foundational
• Approval GateA pipeline checkpoint that pauses deployment until a person approves or an automated condition is met.Foundational
• Argo CDA declarative GitOps continuous delivery tool for Kubernetes that syncs cluster state with manifests stored in Git.Intermediate
• Artifact RepositoryA service that stores and versions build outputs and dependency packages, such as Nexus, Artifactory, Azure Artifacts, AWS CodeArtifact, or GitHub Packages.Intermediate
• Artifact SigningCryptographically signing build artifacts or container images so consumers can verify their origin and integrity.Advanced
• AWS Cloud Development Kit (AWS CDK)An open-source framework for defining AWS infrastructure in programming languages that synthesizes CloudFormation templates.Intermediate
• AWS CloudFormationAWS's native infrastructure as code service that provisions resources from JSON or YAML templates as stacks.Foundational
• AWS CodeBuildA fully managed AWS build service that compiles code, runs tests, and produces artifacts using a buildspec.yml file.Foundational
• AWS CodeDeployAn AWS service that automates application deployments to EC2, on-premises servers, Lambda, and ECS using an appspec file.Intermediate
• AWS CodePipelineA fully managed AWS service that orchestrates release pipelines with source, build, test, approval, and deploy stages.Foundational
• AWS Serverless Application Model (AWS SAM)An AWS framework that extends CloudFormation with simplified syntax for serverless resources like Lambda functions and APIs.Intermediate
• Azure DevOpsMicrosoft's suite of developer services: Azure Boards, Repos, Pipelines, Test Plans, and Artifacts.Foundational
• Azure PipelinesThe CI/CD service in Azure DevOps that builds, tests, and deploys code using YAML or classic pipelines on Microsoft-hosted or self-hosted agents.Foundational
• Azure Resource Manager Template (ARM template)A JSON file that declaratively defines Azure resources for deployment through Azure Resource Manager.Intermediate
• BackstageAn open-source CNCF framework, originally from Spotify, for building developer portals with a software catalog, templates, and plugins.Intermediate
• Behavior-Driven Development (BDD)A practice that describes system behavior in plain-language scenarios, typically Given/When/Then, that become automated acceptance tests.Intermediate
• BicepMicrosoft's domain-specific language for declaratively deploying Azure resources, which transpiles to ARM JSON templates.Intermediate
• Bind MountMounting a specific file or directory from the host filesystem into a container.Foundational
• Blameless PostmortemA written review of an incident that focuses on systemic causes and improvements rather than assigning individual fault.Foundational
• Blue-Green DeploymentA release strategy using two identical production environments, switching all traffic from the current (blue) to the new (green) version at once.Intermediate
• BranchA movable pointer to a commit that represents an independent line of development in Git.Foundational
• Branch Protection RuleRepository settings that enforce policies on important branches, such as required reviews, status checks, and no force pushes.Foundational
• Build ArtifactA versioned output of a build, such as a compiled binary, package, or container image, that is promoted through environments.Foundational
• Build CacheReusing previously downloaded dependencies or build outputs between pipeline runs to speed up builds.Intermediate
• Build Once, Deploy ManyThe principle that a single immutable build artifact is created once and promoted unchanged to every environment.Foundational
• BuildahA Red Hat tool for building OCI container images without a daemon, from Dockerfiles or scripted commands.Advanced
• Burn RateHow fast a service is consuming its error budget relative to the rate that would exactly exhaust it at the end of the SLO window.Advanced
• CALMS FrameworkA DevOps maturity model covering Culture, Automation, Lean, Measurement, and Sharing.Foundational
• Capacity PlanningForecasting the compute, storage, and network resources a service needs to meet demand and SLOs.Intermediate
• CardinalityIn observability, the number of unique time series created by the combinations of metric label values.Advanced
• Change Failure Rate (CFR)A DORA metric measuring the percentage of deployments that cause a failure in production requiring remediation.Foundational
• Change SetA CloudFormation preview of the changes a stack update will make, which can be reviewed before execution.Intermediate
• Chaos EngineeringThe discipline of experimenting on a system by injecting controlled failures to build confidence in its resilience.Intermediate
• Check ModeAnsible's dry-run mode (--check) that reports what would change without making changes, often combined with --diff.Intermediate
• ChefAn agent-based configuration management tool (now Progress Chef) that uses Ruby-based recipes and cookbooks.Foundational
• CI/CD PipelineAn automated sequence of stages that takes code from commit through build, test, and deployment.Foundational
• Cisco Catalyst CenterCisco's enterprise network controller and assurance platform, formerly Cisco DNA Center, with northbound Intent REST APIs.Intermediate
• Cisco Network Services Orchestrator (NSO)Cisco's model-driven, multivendor network orchestration platform that uses YANG service models and network element drivers.Advanced
• CloneCreating a local copy of a remote Git repository, including its full history and a remote named origin.Foundational
• cloud-initThe industry-standard tool for initializing cloud instances at first boot using user data.Intermediate
• CloudFormation StackA collection of AWS resources created and managed as a single unit from a CloudFormation template.Intermediate
• Cluster AutoscalerA Kubernetes component that adds nodes when pods cannot be scheduled and removes underutilized nodes.Intermediate
• Code CoverageThe percentage of code executed by automated tests, measured by lines, branches, or functions.Foundational
• Code ReviewSystematic examination of source code changes by peers to find defects, improve quality, and share knowledge.Foundational
• CODEOWNERSA GitHub/GitLab file that maps paths in a repository to individuals or teams who are automatically requested to review changes.Intermediate
• CodeQLGitHub's semantic code analysis engine that queries code like data to find security vulnerabilities, used for code scanning.Intermediate
• CommitA snapshot of tracked changes in a Git repository, with an author, message, timestamp, and pointer to its parent commit(s).Foundational
• Composite ActionA GitHub Action that bundles multiple workflow steps into a single reusable action defined in action.yml with runs.using: composite.Advanced
• ConfigMapA Kubernetes object that stores non-confidential configuration data as key-value pairs for pods to consume.Foundational
• Configuration DriftDivergence between the actual configuration of a system and its intended, documented, or code-defined state.Intermediate
• Configuration ManagementMaintaining systems in a known, consistent desired state by automating the configuration of operating systems, software, and settings.Foundational
• ContainerA lightweight, isolated runtime environment that packages an application with its dependencies and shares the host operating system kernel.Foundational
• Container ImageAn immutable, layered package containing an application, its runtime, libraries, and configuration, used to create containers.Foundational
• Container Network Interface (CNI)A CNCF specification and plugin model for configuring network interfaces for containers, used by Kubernetes for pod networking.Intermediate
• Container RegistryA service that stores and distributes container images, such as Docker Hub, Amazon ECR, Azure Container Registry, Google Artifact Registry, Quay, or Harbor.Foundational
• Container RuntimeThe software that runs containers on a host, such as containerd, CRI-O, or the low-level runc.Intermediate
• Container Runtime Interface (CRI)A Kubernetes gRPC API that lets the kubelet use any compliant container runtime.Intermediate
• Container Storage Interface (CSI)A standard API that lets storage vendors write plugins to expose block and file storage to container orchestrators.Advanced
• containerdA CNCF graduated, industry-standard container runtime that manages image transfer, storage, and container execution.Intermediate
• Continuous Delivery (CD)The practice of keeping software always in a releasable state, with every change automatically built, tested, and deployable to production on demand.Foundational
• Continuous DeploymentThe practice of automatically releasing every change that passes all pipeline stages to production without human intervention.Foundational
• Continuous Integration (CI)The practice of merging code changes into a shared branch frequently, with each change automatically built and tested.Foundational
• Control Groups (cgroups)A Linux kernel feature that limits, accounts for, and isolates CPU, memory, I/O, and other resources for groups of processes.Advanced
• Control PlaneThe Kubernetes components that manage cluster state: kube-apiserver, etcd, kube-scheduler, kube-controller-manager, and cloud-controller-manager.Foundational
• CoreDNSThe default cluster DNS server in Kubernetes that resolves Service and pod names.Intermediate
• count and for_eachTerraform meta-arguments that create multiple instances of a resource or module from a number or a map/set.Intermediate
• CRI-OA lightweight Kubernetes-specific container runtime implementing the CRI with OCI-compatible runtimes.Intermediate
• CronA time-based job scheduler and its five-field schedule syntax (minute, hour, day of month, month, day of week).Foundational
• CronJobA Kubernetes object that creates Jobs on a repeating schedule written in cron syntax.Intermediate
• cURLA command-line tool and library for transferring data with URLs, widely used to test HTTP APIs.Foundational
• Custom Resource Definition (CRD)A Kubernetes API extension that defines a new resource type that can be managed like built-in objects.Advanced
• DaemonSetA Kubernetes workload object that ensures a copy of a pod runs on all (or selected) nodes.Foundational
• Dark LaunchDeploying a feature to production while hiding it from users, so it can be tested with real traffic or infrastructure before release.Intermediate
• Data SerializationConverting in-memory data structures into a format that can be stored or transmitted, and back (deserialization).Foundational
• Data SourceA Terraform construct that reads information about existing infrastructure or external data without managing it.Intermediate
• Declarative ConfigurationSpecifying the desired end state of a system and letting a tool determine the steps to reach it.Foundational
• DependabotA GitHub feature that alerts on vulnerable dependencies and automatically opens pull requests to update them.Foundational
• Dependency Lock FileTerraform's .terraform.lock.hcl file recording exact provider versions and checksums selected during init.Intermediate
• Dependency ManagementDeclaring, resolving, pinning, and updating the external libraries an application relies on.Foundational
• DeploymentA Kubernetes workload object that manages ReplicaSets to provide declarative updates, scaling, and rollback for stateless pods.Foundational
• Deployment FrequencyA DORA metric measuring how often an organization successfully deploys code to production.Foundational
• Dev ContainerA container-based development environment defined by devcontainer.json, used by VS Code, Codespaces, and other tools.Intermediate
• DevOpsA culture and set of practices that unify software development and IT operations to deliver changes quickly, safely, and reliably.Foundational
• DevSecOpsThe integration of security practices and automated security testing into every stage of the DevOps pipeline.Intermediate
• Distributed TracingTracking a single request as it flows across multiple services by propagating a trace context and recording timed spans.Intermediate
• Distroless ImageA minimal container image containing only the application and its runtime dependencies, without a shell or package manager.Advanced
• DockerA platform and toolset for building, shipping, and running containers, including Docker Engine, the docker CLI, Docker Compose, and Docker Desktop.Foundational
• Docker ComposeA tool for defining and running multi-container applications using a compose.yaml file.Foundational
• Docker EngineThe client-server application consisting of the dockerd daemon, a REST API, and the docker CLI that builds and runs containers.Intermediate
• Docker HubDocker's public cloud registry hosting official images, verified publisher images, and user repositories.Foundational
• Docker LayerA read-only filesystem diff produced by a Dockerfile instruction; images are stacks of layers combined by a union filesystem.Intermediate
• Docker Network DriverThe networking mode for Docker containers: bridge, host, overlay, macvlan, ipvlan, or none.Intermediate
• Docker SwarmDocker's built-in container orchestration mode that clusters Docker hosts into managers and workers running replicated services.Intermediate
• Docker VolumeDocker-managed persistent storage that exists independently of a container's lifecycle.Foundational
• DockerfileA text file of instructions (FROM, RUN, COPY, CMD, and others) that Docker uses to build a container image.Foundational
• DORA MetricsFour key software delivery metrics from the DevOps Research and Assessment program: deployment frequency, lead time, change failure rate, and recovery time.Intermediate
• Dynamic Application Security Testing (DAST)Testing a running application from the outside by sending crafted requests to find vulnerabilities.Intermediate
• Elastic Stack (ELK)A log and search platform made up of Elasticsearch, Logstash, Kibana, and Beats, commonly called the ELK stack.Foundational
• End-to-End Test (E2E)An automated test that validates a complete user workflow through the entire application stack.Foundational
• ENTRYPOINTA Dockerfile instruction defining the executable that always runs when a container starts; CMD supplies default arguments.Intermediate
• Environment PromotionMoving the same tested artifact through successive environments such as dev, test, staging, and production.Foundational
• Environment Protection RulesRules on GitHub Actions deployment environments, such as required reviewers, wait timers, and branch restrictions, that gate jobs.Intermediate
• EnvoyA high-performance CNCF graduated L4/L7 proxy designed for cloud-native applications and used as the data plane of many service meshes.Advanced
• Ephemeral ContainerA temporary container added to a running pod for interactive troubleshooting with kubectl debug.Advanced
• Ephemeral EnvironmentA short-lived, automatically created environment for testing a branch or pull request, destroyed after use.Intermediate
• Error BudgetThe allowable amount of unreliability for a service, equal to 100% minus the SLO, which teams can spend on releases and risk.Intermediate
• Error Budget PolicyAn agreed set of actions a team takes when a service consumes or exhausts its error budget.Advanced
• etcdA distributed, consistent key-value store that holds all Kubernetes cluster state.Intermediate
• Event-Driven AutomationAutomation that triggers workflows in response to events such as alerts, webhooks, telemetry thresholds, or log messages.Advanced
• Exception HandlingManaging runtime errors in code with constructs such as try, except, else, and finally in Python.Foundational
• Expression ContextObjects such as github, env, secrets, vars, matrix, needs, and steps that GitHub Actions workflows access using ${{ }} syntax.Advanced
• Extensible Markup Language (XML)A markup language for structured data using nested, tag-delimited elements with attributes and namespaces.Foundational
• Failed Deployment Recovery TimeA DORA metric, formerly called time to restore service (MTTR), measuring how long it takes to recover from a failed deployment.Intermediate
• Fast-Forward MergeA merge where Git simply moves the branch pointer forward because the target branch has no commits not already in the source.Intermediate
• Feature BranchA branch created to develop a specific feature or fix in isolation before merging it back into the main branch.Foundational
• Feature FlagA runtime switch that enables or disables functionality without deploying new code, also called a feature toggle.Intermediate
• Flaky TestAn automated test that passes and fails intermittently without code changes.Intermediate
• FluentdAn open-source CNCF graduated log collector that unifies log collection, parsing, buffering, and routing to many outputs.Intermediate
• FluxA CNCF graduated GitOps toolkit that keeps Kubernetes clusters in sync with configuration sources such as Git repositories and OCI artifacts.Intermediate
• ForkA server-side copy of another user's repository under your own account, used to propose changes without write access to the original.Foundational
• Four Golden SignalsThe four key metrics Google SRE recommends monitoring for any user-facing system: latency, traffic, errors, and saturation.Foundational
• Game DayA planned exercise where teams simulate failures or incidents to test systems, runbooks, and response processes.Intermediate
• Gateway APIThe Kubernetes successor to Ingress providing role-oriented, extensible resources such as GatewayClass, Gateway, and HTTPRoute.Advanced
• GitA free, open-source distributed version control system that tracks changes to files and enables collaborative development.Foundational
• git bisectA Git command that performs a binary search through commit history to find the commit that introduced a bug.Advanced
• git cherry-pickA Git command that applies the changes from a specific existing commit onto the current branch as a new commit.Intermediate
• Git HookA script Git runs automatically at points such as pre-commit, commit-msg, or pre-push, or on the server at pre-receive.Intermediate
• Git Large File Storage (Git LFS)A Git extension that stores large binary files outside the repository, replacing them with small pointer files.Intermediate
• git logA Git command that displays commit history with authors, dates, messages, and optionally diffs and graphs.Foundational
• git pullA Git command that fetches changes from a remote and integrates them into the current branch.Foundational
• git pushA Git command that uploads local branch commits to a remote repository.Foundational
• git resetA Git command that moves the current branch pointer to a specified commit, optionally changing the staging area and working tree.Intermediate
• git revertA Git command that creates a new commit that undoes the changes made by a previous commit.Foundational
• git stashA Git command that temporarily shelves uncommitted changes so you can work on something else and reapply them later.Intermediate
• Git SubmoduleA repository embedded inside another Git repository at a specific commit.Advanced
• Git TagA named reference to a specific commit, typically used to mark release versions.Foundational
• GitFlowA branching model with long-lived main and develop branches plus feature, release, and hotfix branches.Intermediate
• GitHubA cloud platform for hosting Git repositories with collaboration, code review, CI/CD (Actions), package hosting, and security features.Foundational
• GitHub ActionsGitHub's integrated CI/CD and automation platform that runs YAML-defined workflows in response to repository events.Foundational
• GitHub Actions WorkflowA configurable automated process defined in a YAML file in .github/workflows that contains one or more jobs.Foundational
• GitHub Advanced Security (GHAS)GitHub's security product suite including code scanning, secret scanning with push protection, and dependency review.Intermediate
• GitHub CodespacesCloud-hosted development environments on GitHub, configured by a devcontainer.json file.Foundational
• GitHub FlowA lightweight branching workflow: create a branch from main, commit, open a pull request, review, merge, and deploy.Foundational
• GitHub IssuesGitHub's tracking feature for bugs, tasks, and feature requests, linked to pull requests, labels, milestones, and projects.Foundational
• GitHub MarketplaceGitHub's catalog of reusable Actions and Apps that extend GitHub workflows and integrations.Foundational
• GitHub PackagesGitHub's package hosting service supporting container images, npm, Maven, Gradle, NuGet, and RubyGems registries.Foundational
• GitHub ProjectsA flexible planning tool on GitHub that tracks issues and pull requests in table, board, and roadmap views with custom fields.Foundational
• GitHub SecretsEncrypted variables stored at the organization, repository, or environment level for use in GitHub Actions workflows.Intermediate
• GITHUB_TOKENAn automatically generated, short-lived token that GitHub Actions provides to each workflow run for authenticating to the GitHub API.Intermediate
• GitLab CI/CDGitLab's built-in CI/CD system, configured with a .gitlab-ci.yml file defining stages and jobs run by GitLab Runners.Foundational
• GitOpsAn operating model where desired infrastructure and app state is stored declaratively in Git and automatically reconciled to the live environment.Intermediate
• Golden PathAn opinionated, supported, well-documented way to build and deploy a particular type of software within an organization.Intermediate
• Google Cloud BuildGoogle Cloud's serverless CI/CD service that executes build steps as containers defined in cloudbuild.yaml.Foundational
• Google Cloud DeployA managed Google Cloud continuous delivery service that promotes releases through a sequence of targets such as GKE, Cloud Run, or GKE Enterprise clusters.Intermediate
• GrafanaAn open-source visualization and dashboarding platform that queries data sources such as Prometheus, Loki, Elasticsearch, and cloud monitoring services.Foundational
• GraphQLA query language and runtime for APIs that lets clients request exactly the fields they need from a single endpoint.Intermediate
• gRPCA high-performance open-source RPC framework that uses HTTP/2 transport and Protocol Buffers serialization.Intermediate
• gRPC Network Management Interface (gNMI)An OpenConfig gRPC-based protocol for retrieving and modifying configuration and streaming telemetry using YANG-modeled paths.Advanced
• HashiCorp Configuration Language (HCL)The declarative configuration language used by Terraform, Packer, Nomad, and other HashiCorp tools.Foundational
• HashiCorp VaultA secrets management tool that stores static secrets, generates dynamic credentials, and provides encryption as a service.Intermediate
• HCP TerraformHashiCorp's managed service, formerly Terraform Cloud, for running Terraform remotely with shared state, policy, and collaboration.Intermediate
• HEADA Git reference to the currently checked-out commit, usually pointing indirectly to the current branch.Intermediate
• Headless ServiceA Kubernetes Service with clusterIP: None that returns individual pod IPs via DNS instead of a single virtual IP.Advanced
• Health Check EndpointAn HTTP endpoint such as /healthz or /ready that reports whether a service is alive and able to serve requests.Foundational
• HelmThe package manager for Kubernetes that templates, installs, upgrades, and rolls back applications packaged as charts.Intermediate
• Helm ChartA Helm package containing Chart.yaml, values.yaml, and Go-templated Kubernetes manifests in a templates directory.Intermediate
• Helm ReleaseA specific installed instance of a Helm chart in a cluster, tracked with a name and revision history.Intermediate
• Helm RepositoryAn HTTP server or OCI registry that hosts packaged Helm charts and an index for discovery.Intermediate
• Horizontal Pod Autoscaler (HPA)A Kubernetes controller that scales the number of pod replicas based on CPU, memory, or custom metrics.Intermediate
• hostPathA Kubernetes volume type that mounts a file or directory from the node's filesystem into a pod.Advanced
• HotfixAn urgent fix applied to production to resolve a critical defect, usually outside the normal release cadence.Foundational
• HTTP MethodsThe verbs used in HTTP requests, chiefly GET, POST, PUT, PATCH, and DELETE, that map to read, create, replace, partial update, and delete operations.Foundational
• HTTP Status CodesThree-digit codes in HTTP responses indicating results: 1xx informational, 2xx success, 3xx redirection, 4xx client error, 5xx server error.Foundational
• IdempotencyThe property that applying the same operation multiple times produces the same result as applying it once.Foundational
• Image DigestThe immutable sha256 content hash that uniquely identifies a specific container image manifest.Intermediate
• Image ScanningAnalyzing container images for known vulnerabilities, misconfigurations, secrets, and license issues.Intermediate
• Image StreamAn OpenShift abstraction that tracks container image references by tag and can trigger builds or deployments when images change.Advanced
• Immutable InfrastructureAn approach where servers or containers are never modified after deployment; changes are made by replacing them with new instances built from a new image.Intermediate
• Imperative ConfigurationSpecifying the explicit sequence of commands or steps needed to change a system's state.Foundational
• Incident Commander (IC)The person who coordinates the overall response to a major incident, delegating work and managing communication rather than fixing the issue directly.Intermediate
• Infrastructure as Code (IaC)Managing and provisioning infrastructure through machine-readable definition files rather than manual configuration.Foundational
• Infrastructure PipelineA CI/CD pipeline that validates, plans, and applies infrastructure as code changes.Intermediate
• IngressA Kubernetes API object that manages external HTTP/HTTPS access to Services with host- and path-based routing and TLS termination.Intermediate
• Ingress ControllerA component running in the cluster that implements Ingress rules by configuring a reverse proxy or cloud load balancer.Intermediate
• Init ContainerA container in a pod that runs to completion before the app containers start, used for setup tasks.Intermediate
• Integration TestAn automated test that verifies multiple components or services work together correctly.Foundational
• Internal Developer Platform (IDP)A self-service layer, built by a platform team, that lets developers provision environments and deploy applications without filing tickets.Intermediate
• IstioA CNCF graduated open-source service mesh using Envoy proxies to provide traffic management, security, and observability.Advanced
• JaegerAn open-source CNCF graduated distributed tracing platform for collecting, storing, and visualizing traces.Intermediate
• JavaScript Object Notation (JSON)A lightweight, text-based data interchange format of objects (key-value pairs) and arrays, widely used by REST APIs.Foundational
• JenkinsA widely used open-source automation server for building CI/CD pipelines, extended through thousands of plugins.Foundational
• Jinja2A Python templating engine used by Ansible, Salt, and network automation scripts to generate configurations from variables.Intermediate
• JobIn CI/CD, a set of steps that execute on the same runner; in GitHub Actions jobs run in parallel unless linked with needs.Foundational
• JSON Web Token (JWT)A compact, URL-safe token format consisting of a base64url-encoded header, payload of claims, and signature.Intermediate
• Junos PyEZJuniper's Python library for managing Junos devices over NETCONF with structured RPCs, configuration utilities, and tables/views.Intermediate
• KanbanA flow-based work management method that visualizes work on a board, limits work in progress, and manages flow.Foundational
• kube-apiserverThe Kubernetes component that exposes the REST API and is the front end and only component that talks directly to etcd.Intermediate
• kube-controller-managerThe control plane component that runs core controllers such as the Deployment, ReplicaSet, Node, and Job controllers.Intermediate
• kube-proxyA node component that maintains network rules (iptables, IPVS, or nftables) to implement Kubernetes Service virtual IPs.Advanced
• kube-schedulerThe control plane component that assigns newly created pods to suitable nodes.Intermediate
• kubeadmA Kubernetes tool that bootstraps a minimum viable cluster and manages upgrades and certificates.Intermediate
• kubeconfigA YAML file that stores cluster endpoints, user credentials, and contexts used by kubectl.Foundational
• kubectlThe Kubernetes command-line tool for interacting with the API server to create, inspect, update, and delete resources.Foundational
• kubeletThe node agent that ensures containers described in PodSpecs are running and healthy on each Kubernetes node.Intermediate
• Kubernetes (K8s)An open-source CNCF container orchestration platform that automates deployment, scaling, networking, and self-healing of containerized applications.Foundational
• Kubernetes JobA Kubernetes workload that runs pods to completion for batch tasks, retrying failures up to a backoff limit.Intermediate
• Kubernetes SecretA Kubernetes object for storing small amounts of sensitive data such as passwords, tokens, and TLS keys.Foundational
• Kusto Query Language (KQL)A read-only query language used in Azure Monitor Log Analytics, Application Insights, Microsoft Sentinel, and Azure Data Explorer.Intermediate
• KustomizeA template-free tool, built into kubectl, that customizes Kubernetes YAML using bases, overlays, and patches.Intermediate
• KyvernoA CNCF Kubernetes-native policy engine that validates, mutates, generates, and verifies resources using policies written as YAML.Advanced
• Label and SelectorKey-value pairs attached to Kubernetes objects (labels) and the queries that match them (selectors).Foundational
• Lead Time for ChangesA DORA metric measuring the time from code being committed to that code running successfully in production.Foundational
• LimitRangeA Kubernetes namespace policy that sets default, minimum, and maximum resource requests and limits for containers or pods.Advanced
• LinkerdA lightweight CNCF graduated service mesh that uses its own Rust-based micro-proxy to add mTLS, reliability, and observability.Advanced
• LintingAutomated static checking of source code or configuration for style issues, errors, and suspicious constructs.Foundational
• Linux NamespacesA Linux kernel feature that isolates process views of system resources such as PIDs, network, mounts, users, IPC, and hostnames.Advanced
• Liveness ProbeA Kubernetes health check that restarts a container when it fails, indicating the container is unhealthy or stuck.Intermediate
• Local Kubernetes ClusterA single-machine Kubernetes environment for development and testing, such as minikube, kind, k3d, or Docker Desktop Kubernetes.Foundational
• Log AggregationCollecting logs from many systems into a central store for search, correlation, retention, and alerting.Foundational
• LokiA horizontally scalable log aggregation system from Grafana Labs that indexes only log labels, not full log content.Advanced
• ManifestA YAML or JSON file describing Kubernetes objects with apiVersion, kind, metadata, and spec fields.Foundational
• Matrix StrategyA CI feature that runs the same job multiple times across combinations of variables such as OS and language version.Intermediate
• MergeCombining the changes from one Git branch into another, creating a merge commit when histories have diverged.Foundational
• Merge ConflictA situation where Git cannot automatically combine changes because the same part of a file was modified differently in both branches.Foundational
• Metric TypesThe kinds of metrics used in monitoring systems such as Prometheus: counter, gauge, histogram, and summary.Intermediate
• Microservices ArchitectureAn architectural style that structures an application as small, independently deployable services communicating over APIs.Foundational
• MockingReplacing real dependencies in tests with controllable fake objects that simulate behavior and record interactions.Intermediate
• Model-Driven Telemetry (MDT)Streaming YANG-modeled operational data from network devices to collectors, replacing periodic SNMP polling.Advanced
• Model-View-Controller (MVC)A software design pattern that separates an application into the data model, the user interface view, and the controller that handles input.Intermediate
• MonitoringCollecting, aggregating, and alerting on predefined metrics and checks to detect known failure conditions.Foundational
• MonorepoA single repository that contains code for many projects or services.Intermediate
• Multi-Stage BuildA Dockerfile technique using multiple FROM stages so build tools stay in early stages and only needed artifacts are copied to the final image.Intermediate
• Mutable InfrastructureInfrastructure that is updated in place after provisioning, for example by patching or reconfiguring running servers.Foundational
• Mutual TLS (mTLS)TLS in which both client and server present and verify certificates, providing two-way authentication and encryption.Intermediate
• NamespaceA Kubernetes mechanism for dividing a cluster into virtual partitions that scope names, policies, quotas, and access control.Foundational
• NAPALMNetwork Automation and Programmability Abstraction Layer with Multivendor support, a Python library offering a unified API across network operating systems.Advanced
• ncclientA Python library for NETCONF client operations against network devices.Intermediate
• NetBoxAn open-source network source of truth for IPAM and DCIM data, with REST and GraphQL APIs used to drive automation.Intermediate
• NETCONFThe Network Configuration Protocol (RFC 6241), an XML-based RPC protocol over SSH (port 830) for installing, manipulating, and deleting device configuration.Intermediate
• NETCONF DatastoresConceptual configuration stores accessed by NETCONF: running, candidate, and startup.Advanced
• NetmikoA Python library that simplifies SSH connections to network devices for sending CLI commands and configuration across many vendors.Intermediate
• Network PolicyA Kubernetes resource that controls allowed ingress and egress traffic for selected pods at the IP and port level.Intermediate
• Network ProgrammabilityUsing software, APIs, and data models to configure, monitor, and operate networks programmatically instead of by CLI.Foundational
• NodeA worker machine, virtual or physical, in a Kubernetes cluster that runs pods.Foundational
• Node AffinityKubernetes rules that constrain which nodes a pod can be scheduled on based on node labels.Intermediate
• Northbound and Southbound APIsController interfaces: northbound APIs face applications and users, while southbound APIs face network devices.Foundational
• OAuth 2.0An authorization framework that lets applications obtain limited, delegated access tokens to APIs without handling user passwords.Intermediate
• Object-Oriented Programming (OOP)A programming paradigm that organizes code into classes and objects combining data (attributes) and behavior (methods).Intermediate
• ObservabilityThe ability to understand a system's internal state from its external outputs, typically metrics, logs, and traces.Foundational
• oc CLIThe OpenShift command-line client, a superset of kubectl with OpenShift-specific commands.Intermediate
• On-Call RotationA schedule that assigns engineers responsibility for responding to production alerts during defined periods.Foundational
• Open Container Initiative (OCI)A Linux Foundation project defining open standards for container image format, runtime, and distribution.Intermediate
• Open Policy Agent (OPA)A CNCF graduated general-purpose policy engine that evaluates policies written in Rego against JSON input.Advanced
• OpenAPI Specification (OAS)A vendor-neutral standard (formerly Swagger) for describing REST APIs in YAML or JSON, including paths, parameters, schemas, and authentication.Intermediate
• OpenConfigAn operator-led initiative that defines vendor-neutral YANG models and the gNMI/gNOI specifications for network management.Advanced
• OpenID Connect for CI/CD (OIDC)Using short-lived OIDC tokens issued by a CI platform to authenticate to cloud providers without storing long-lived credentials.Advanced
• OpenShift PipelinesOpenShift's cloud-native CI/CD offering based on Tekton, installed through an operator.Advanced
• OpenShift ProjectAn OpenShift wrapper around a Kubernetes namespace that adds annotations and controlled self-service creation.Foundational
• OpenShift RouteAn OpenShift resource that exposes a Service at an external hostname through the cluster's router (HAProxy-based ingress).Intermediate
• OpenTelemetry (OTel)A CNCF open standard and set of SDKs, APIs, and a collector for generating and exporting metrics, logs, and traces vendor-neutrally.Intermediate
• OpenTelemetry CollectorA vendor-agnostic agent or gateway that receives, processes, and exports telemetry data using pipelines of receivers, processors, and exporters.Advanced
• OpenTofuAn open-source, Linux Foundation-hosted fork of Terraform created after HashiCorp's license change, compatible with most Terraform configurations.Intermediate
• OperatorA Kubernetes extension that uses custom resources and a controller to automate the lifecycle of complex applications.Advanced
• Operator Lifecycle Manager (OLM)A component that installs, updates, and manages the lifecycle of Kubernetes operators, central to OpenShift.Advanced
• PackerA HashiCorp tool that builds identical machine images for multiple platforms from a single HCL template.Intermediate
• Percentile LatencyA latency measure, such as p95 or p99, indicating the value below which a given percentage of requests fall.Intermediate
• Persistent Volume (PV)A cluster-scoped Kubernetes storage resource provisioned by an administrator or dynamically by a StorageClass.Intermediate
• Persistent Volume Claim (PVC)A namespaced request for storage by a user that binds to a matching PersistentVolume.Intermediate
• Pets vs CattleAn analogy contrasting uniquely cared-for servers (pets) with interchangeable, replaceable servers (cattle).Foundational
• pipThe standard package installer for Python, which installs packages from the Python Package Index (PyPI) or other indexes.Foundational
• Pipeline as CodeDefining CI/CD pipelines in version-controlled files, usually YAML, stored alongside application code.Foundational
• Platform EngineeringThe discipline of building and running internal self-service platforms that give developers paved paths to build, deploy, and operate software.Intermediate
• PodThe smallest deployable unit in Kubernetes: one or more containers sharing network namespace, storage volumes, and a lifecycle.Foundational
• Pod Disruption Budget (PDB)A Kubernetes policy limiting how many pods of an application can be voluntarily disrupted at once, such as during node drains.Advanced
• Pod Security Standards (PSS)Three Kubernetes security profiles (Privileged, Baseline, Restricted) enforced per namespace by the built-in Pod Security Admission controller.Advanced
• PodmanA daemonless, open-source container engine from Red Hat with a Docker-compatible CLI that supports rootless containers and pods.Intermediate
• Policy as CodeExpressing security, compliance, and operational policies in code that is versioned and automatically evaluated.Intermediate
• Port PublishingMapping a host port to a container port so external clients can reach a containerized service.Foundational
• PostmanA popular API platform for building, sending, testing, and documenting HTTP requests, with collections, environments, and scripting.Foundational
• PowerShell Desired State Configuration (DSC)A Microsoft declarative configuration management platform for defining and enforcing the configuration of Windows and cross-platform systems.Advanced
• Progressive DeliveryAn evolution of continuous delivery that releases changes gradually with automated analysis, using canaries, feature flags, and traffic shaping.Advanced
• PrometheusAn open-source CNCF graduated monitoring system and time-series database that scrapes metrics over HTTP and supports alerting with PromQL.Intermediate
• Prometheus ExporterA process that exposes metrics from a third-party system in Prometheus format on an HTTP endpoint.Intermediate
• PromQLThe Prometheus Query Language used to select, aggregate, and compute on time-series metrics.Advanced
• Protocol Buffers (Protobuf)Google's language-neutral binary serialization format defined by .proto schemas.Advanced
• Pull Request (PR)A request to merge changes from one branch into another, providing a place for code review, discussion, and automated checks.Foundational
• PulumiAn infrastructure as code platform that defines cloud resources using general-purpose languages like Python, TypeScript, Go, and C#.Intermediate
• PuppetAn agent-based configuration management tool using a declarative DSL in manifests and modules, with agents pulling catalogs from a server.Foundational
• Push vs Pull Configuration ModelWhether a central server pushes configuration to nodes or nodes periodically pull configuration from a server.Intermediate
• PushgatewayA Prometheus component that lets short-lived or batch jobs push metrics so Prometheus can scrape them later.Advanced
• pyATSCisco's Python test automation framework, with the Genie library for parsing, learning, and comparing network device state.Intermediate
• pytestA popular Python testing framework that discovers test_*.py files and uses plain assert statements with rich failure reporting.Intermediate
• PythonA high-level, interpreted, general-purpose programming language widely used for automation, scripting, data processing, and network programmability.Foundational
• Python DictionaryA mutable Python mapping of unique, hashable keys to values, the natural representation of JSON objects.Foundational
• Python FunctionA reusable block of Python code defined with def that takes parameters and optionally returns a value.Foundational
• Python Requests LibraryThe de facto Python HTTP client library for calling REST APIs.Foundational
• Quality GateA set of automated pass/fail criteria, such as test pass rate, coverage, or vulnerability thresholds, that a build must meet to proceed.Intermediate
• Quality of Service Class (QoS)The Kubernetes classification of pods as Guaranteed, Burstable, or BestEffort based on their requests and limits.Advanced
• Readiness ProbeA Kubernetes check that determines whether a pod can receive traffic; failing pods are removed from Service endpoints.Intermediate
• Real User Monitoring (RUM)Collecting performance and error data from actual users' browsers or devices as they interact with an application.Intermediate
• RebaseReapplying commits from one branch on top of another base commit, producing a linear history.Intermediate
• Reconciliation LoopThe control-loop pattern in which a controller repeatedly compares desired state with actual state and acts to close the gap.Intermediate
• Red Hat OpenShiftRed Hat's enterprise Kubernetes platform that adds integrated developer tools, security defaults, operators, and a web console.Intermediate
• RED MethodA request-centric monitoring approach tracking Rate, Errors, and Duration for every service.Intermediate
• RefactoringRestructuring existing code to improve readability, maintainability, or performance without changing its external behavior.Foundational
• Regression TestRe-running tests after a change to ensure previously working functionality still works.Foundational
• Release PipelineThe portion of a delivery pipeline responsible for deploying approved artifacts to environments and managing releases.Foundational
• RemoteA named reference to another copy of a Git repository, typically hosted on a server, used for fetching and pushing.Foundational
• Remote BackendA Terraform backend that stores state remotely, such as in S3, Azure Blob Storage, Google Cloud Storage, or HCP Terraform, enabling team sharing and locking.Intermediate
• ReplicaSetA Kubernetes controller that maintains a stable set of identical pod replicas.Foundational
• RepositoryA storage location that holds a project's files and their complete version history in a version control system.Foundational
• Representational State Transfer (REST)An architectural style for web APIs that uses stateless HTTP requests on resources identified by URIs.Foundational
• Required Status CheckA CI check that must pass before a pull request can be merged into a protected branch.Intermediate
• Resilience TestingTesting how a system tolerates and recovers from failures, load spikes, and degraded dependencies.Intermediate
• Resource QuotaA Kubernetes object that limits aggregate resource consumption and object counts within a namespace.Intermediate
• Resource Requests and LimitsKubernetes settings that declare the minimum CPU/memory a container needs (requests) and the maximum it may use (limits).Intermediate
• RESTCONFAn HTTP-based protocol (RFC 8040) that provides a REST-like interface to YANG-modeled data, using XML or JSON over HTTPS.Intermediate
• Reusable WorkflowA GitHub Actions workflow triggered by workflow_call that other workflows can invoke as a job.Advanced
• Role-Based Access Control (RBAC)The Kubernetes authorization mode that grants permissions through Roles/ClusterRoles bound to users, groups, or service accounts.Intermediate
• Roll ForwardFixing a failed release by deploying a new corrective version rather than reverting to the previous one.Intermediate
• RollbackReverting a system to a previous known-good version after a failed or problematic change.Foundational
• Rolling DeploymentA release strategy that gradually replaces instances of the old version with the new version in batches.Foundational
• Root Cause Analysis (RCA)A structured investigation to identify the underlying causes of an incident so they can be eliminated.Foundational
• Rootless ContainerA container run by an unprivileged user, using user namespaces so root inside the container maps to a non-root host user.Advanced
• RunbookA documented procedure describing how to perform a routine operational task or respond to a specific alert.Foundational
• RunnerA machine or container that executes CI/CD jobs, called a runner in GitHub Actions and GitLab and an agent in Azure Pipelines and Jenkins.Foundational
• SaltA Python-based configuration management and remote execution tool (SaltStack, now owned by Broadcom) using a master/minion architecture over a ZeroMQ event bus.Intermediate
• ScriptingWriting small programs, typically in interpreted languages such as Bash, Python, or PowerShell, to automate repetitive tasks.Foundational
• Secret ScanningAutomatically detecting credentials such as API keys, tokens, and passwords committed to source repositories.Intermediate
• Secrets ManagementSecurely storing, distributing, rotating, and auditing credentials such as passwords, API keys, and certificates.Foundational
• Security ContextPod- and container-level Kubernetes settings that define privilege and access controls such as user ID, capabilities, and read-only filesystems.Advanced
• Security Context Constraints (SCC)OpenShift resources that control the security permissions pods can request, such as running as root or using host resources.Advanced
• Semantic Versioning (SemVer)A versioning scheme of MAJOR.MINOR.PATCH where major indicates breaking changes, minor adds compatible features, and patch fixes bugs.Foundational
• SentinelHashiCorp's policy-as-code framework that enforces rules on Terraform runs in HCP Terraform and Terraform Enterprise.Advanced
• ServiceA Kubernetes object that provides a stable virtual IP and DNS name to load balance traffic to a set of pods selected by labels.Foundational
• Service AccountA Kubernetes identity for processes running in pods to authenticate to the API server and, via federation, to cloud services.Intermediate
• Service ConnectionAn Azure DevOps object that securely stores credentials pipelines use to access external services such as Azure subscriptions, registries, or Kubernetes.Intermediate
• Service Level Indicator (SLI)A quantitative measure of some aspect of a service's level of service, such as request latency, error rate, or availability.Foundational
• Service Level Objective (SLO)A target value or range for an SLI over a time window, such as 99.9% of requests succeeding over 30 days.Foundational
• Service MeshAn infrastructure layer that manages service-to-service communication with traffic management, mTLS security, and observability, usually via proxies.Intermediate
• Service TypesThe Kubernetes Service exposure modes: ClusterIP, NodePort, LoadBalancer, and ExternalName.Foundational
• Shift LeftThe practice of moving testing, security, and quality activities earlier in the software delivery lifecycle.Foundational
• Shift-Right TestingTesting and validating software in production using monitoring, canaries, feature flags, chaos experiments, and real user data.Intermediate
• Sidecar ContainerA helper container that runs alongside the main application container in the same pod to extend its functionality.Intermediate
• Signed CommitA Git commit cryptographically signed with GPG, SSH, or S/MIME keys to verify the author's identity.Advanced
• Simple Network Management Protocol (SNMP)A traditional UDP-based protocol for monitoring and managing network devices using MIBs, polling (ports 161) and traps (port 162).Foundational
• Site Reliability Engineering (SRE)A discipline, created at Google, that applies software engineering to operations problems to build scalable and highly reliable systems.Foundational
• SkopeoA command-line tool for inspecting, copying, and signing container images between registries without pulling them locally.Advanced
• Smoke TestA quick, shallow test run after a build or deployment to confirm the most critical functions work.Foundational
• SOAPA legacy XML-based messaging protocol for web services that wraps requests in an envelope and is described by WSDL.Intermediate
• Software Bill of Materials (SBOM)A formal, machine-readable inventory of all components and dependencies in a piece of software.Intermediate
• Software Composition Analysis (SCA)Identifying open-source and third-party dependencies in software and checking them for known vulnerabilities and license issues.Intermediate
• Software-Defined Networking (SDN)A network architecture that separates the control plane from the data plane and centralizes control in software controllers with programmable APIs.Foundational
• Source-to-Image (S2I)An OpenShift build strategy that produces container images by injecting application source code into a builder image.Advanced
• SpanA single named, timed operation within a distributed trace, such as an HTTP call or database query.Intermediate
• Squash MergeCombining all commits from a branch into a single new commit on the target branch.Intermediate
• StackSetsA CloudFormation feature for deploying stacks across multiple AWS accounts and Regions from a single operation.Advanced
• Staging AreaThe Git index where changes are prepared with git add before being recorded in the next commit.Foundational
• Startup ProbeA Kubernetes probe for slow-starting containers that disables liveness and readiness checks until it succeeds.Advanced
• StatefulSetA Kubernetes workload object for stateful applications that need stable network identities, ordered deployment, and persistent storage per pod.Intermediate
• Static Application Security Testing (SAST)Analyzing source code, bytecode, or binaries for security vulnerabilities without executing the application.Intermediate
• Static PodA pod managed directly by the kubelet from a manifest file on the node rather than by the API server.Advanced
• StepAn individual task in a CI job that either runs a shell command or uses a reusable action.Foundational
• Storage ClassA Kubernetes object describing a class of storage and its provisioner, used for dynamic volume provisioning.Intermediate
• Structured LoggingWriting log events as machine-parseable key-value data, typically JSON, rather than free-form text.Foundational
• Supply-chain Levels for Software Artifacts (SLSA)An OpenSSF security framework of graduated levels for ensuring the integrity of build processes and artifact provenance.Advanced
• Synchronous vs Asynchronous APIWhether an API call returns the final result immediately or accepts the request and completes it later, with status retrieved by polling or callback.Intermediate
• Synthetic MonitoringProactively testing an application by running scripted transactions or probes from external locations at regular intervals.Intermediate
• Taints and TolerationsA Kubernetes mechanism where node taints repel pods unless the pods have matching tolerations.Intermediate
• Technical DebtThe implied future cost of rework caused by choosing quick or limited solutions now instead of better approaches.Foundational
• TektonA Kubernetes-native open-source framework for building CI/CD pipelines using custom resources such as Task and Pipeline.Advanced
• Telemetry Subscription ModesThe ways telemetry sessions are established and data is sent: dial-in vs dial-out, and periodic vs on-change.Advanced
• TerraformHashiCorp's infrastructure as code tool that provisions resources across many providers using declarative HCL configuration.Foundational
• terraform importBringing existing infrastructure under Terraform management by recording it in state.Advanced
• Terraform ModuleA reusable container of Terraform resources; every configuration is a root module that can call child modules.Intermediate
• Terraform OutputA value exported from a Terraform module, shown after apply and accessible to parent modules or via terraform output.Foundational
• Terraform PlanThe Terraform command that compares configuration with state and real infrastructure to show proposed create, update, and destroy actions.Foundational
• Terraform ProviderA plugin that lets Terraform interact with an API, such as AWS, Azure, Google Cloud, Kubernetes, or network platforms.Intermediate
• Terraform RegistryHashiCorp's public catalog of Terraform providers and modules at registry.terraform.io.Foundational
• Terraform StateThe file (terraform.tfstate) in which Terraform records the mapping between configuration and real resources, plus metadata.Intermediate
• Terraform VariableAn input variable declared with a variable block that parameterizes Terraform configurations and modules.Intermediate
• Terraform WorkflowThe core Terraform lifecycle: write configuration, then init, plan, apply, and eventually destroy.Foundational
• Terraform WorkspaceNamed instances of state for the same configuration, allowing multiple environments from one working directory.Intermediate
• Test PyramidA testing strategy model recommending many fast unit tests, fewer integration tests, and very few end-to-end tests.Intermediate
• Test-Driven Development (TDD)A development practice of writing a failing test first, writing just enough code to pass it, then refactoring (red-green-refactor).Intermediate
• Three Pillars of ObservabilityThe three primary telemetry types used for observability: metrics, logs, and traces.Foundational
• Three Ways of DevOpsThe principles from The Phoenix Project and The DevOps Handbook: flow, feedback, and continual learning and experimentation.Intermediate
• ToilManual, repetitive, automatable, tactical operational work that scales linearly with service growth and has no enduring value.Foundational
• Traffic MirroringCopying live production requests to a new service version for testing without affecting responses returned to users.Advanced
• Trunk-Based DevelopmentA branching model where developers integrate small changes into a single main branch (trunk) at least daily.Intermediate
• Twelve-Factor AppA methodology of twelve best practices for building portable, scalable, cloud-native software-as-a-service applications.Intermediate
• Unit TestAn automated test that verifies a small, isolated piece of code, such as a function or class, independent of external dependencies.Foundational
• USE MethodA resource-centric performance analysis method checking Utilization, Saturation, and Errors for every resource.Intermediate
• Value Stream Mapping (VSM)A Lean technique that visualizes every step, wait time, and handoff required to deliver a change from request to customer.Intermediate
• Vertical Pod Autoscaler (VPA)A Kubernetes add-on that recommends or automatically adjusts container CPU and memory requests based on usage.Advanced
• Virtual Environment (venv)An isolated Python environment with its own interpreter link and installed packages, separate from the system Python.Foundational
• W3C Trace ContextA W3C standard defining the traceparent and tracestate HTTP headers used to propagate trace identifiers between services.Advanced
• WebhookAn HTTP callback in which a system sends an HTTP POST to a configured URL when an event occurs.Foundational
• Workflow ArtifactFiles produced by a GitHub Actions job and uploaded for sharing between jobs or downloading after a run.Intermediate
• Workflow TriggerThe event, defined under the on key, that causes a GitHub Actions workflow to run.Intermediate
• XPathA query language for selecting nodes in an XML document using path expressions.Advanced
• YAML Ain't Markup LanguageA human-friendly data serialization format using indentation for structure, used by Ansible, Kubernetes, and CI pipelines.Foundational
• YANGYet Another Next Generation (RFC 7950), a data modeling language that defines the structure of configuration and operational data for network devices.Intermediate