Search the practice set
275 questions, 991 terms and 600 topics in 30 areas.
60 results for “Policy as Code”
Policy as Code
Expressing governance rules as executable code evaluated automatically, so compliance is prevented at creation rather than reported after the fact.
Admission Policy
A rule evaluated at the moment a resource is created or changed, which rejects the request rather than reporting on it afterwards.
Clean Architecture
Concentric layers with a strict dependency rule — source code dependencies point only inwards, towards higher-level policy.
Dependency Rule
The constraint that source-code dependencies may point only inward, from detail toward policy, regardless of the direction of control flow.
API Deprecation Policy
The published commitment about how long a version is supported, how notice is given, and what consumers can expect — without which nothing is ever retired.
Authorization Code Flow with PKCE
The OAuth flow recommended for all client types, in which an authorisation code is exchanged for tokens using a proof key that binds the exchange to the original requester.
Code List Governance
Managing the small shared enumerations — currencies, country codes, statuses, product categories — whose uncontrolled change breaks systems quietly.
Content Security Policy
A response header declaring which sources of script, style and other resources the browser may load, which turns a script injection from a compromise into a blocked request.
Data Retention Policy
A defined rule for how long each class of data is kept, where, and what happens at the end of it.
Error Budget Policy
The written agreement about what happens when the error budget is exhausted, which is what turns an SLO from a number into a control.
Infrastructure as Code
Defining infrastructure in version-controlled declarative files that a tool reconciles against the real environment.
Service Control Policy
An organisation-level guardrail that limits what any identity in an account may do, regardless of the permissions granted within that account.
Storage Lifecycle Policy
Automated rules that move objects between storage classes as they age, matching cost to the declining probability that data will be read.
Webhook Retry Policy
The provider's schedule for re-attempting failed deliveries, and the contract the receiver must be built against.
AI Gateway
A shared proxy in front of model providers that centralises routing, keys, quotas, caching, logging and safety policy.
APM Transaction Tracing
Instrumentation that attributes application latency and errors to specific code paths, database queries and external calls, usually with automatic tracing.
Application Performance Monitoring
Instrumentation inside the application that attributes latency and errors to specific code paths, queries and dependencies.
Architectural Debt
Structural compromises that increase the cost of all future change, distinguished from code-level debt by being expensive and slow to repay.
C4 Model
A set of four nested diagram levels — context, container, component, code — that keeps each diagram at one consistent level of abstraction.
Component Library Versioning
Treating a design system as a versioned product with a compatibility policy and a deprecation process, because its consumers cannot all upgrade at once.
Configuration Drift
Divergence between the infrastructure described in code and the infrastructure actually running, usually caused by manual changes.
Continuous Profiling
Sampling CPU, memory and lock profiles from production continuously at low overhead, so resource usage can be attributed to specific code paths.
Data Contract
An explicit, versioned, enforced agreement between a data producer and its consumers about schema, semantics, quality and change policy.
Decision Rights Over Data
Who is entitled to decide what a data element means, who may see it and how long it is kept — the substance of governance once the policy documents are set aside.
Dependency Inversion
The rule that high-level policy should not depend on low-level detail, both depending instead on an abstraction owned by the policy.
Edge Function
Code executed at a CDN point of presence close to the user, in a constrained, fast-starting runtime, typically to modify or route a request before it reaches an origin.
Error Budget
The amount of unreliability an SLO permits, treated as a resource that feature velocity spends.
Event Stream Versioning
Transforming an old event version into the current shape when it is read, allowing a stored event history to be interpreted by evolved code.
Expand-Contract Migration
Changing a schema in additive steps that keep old and new code both working, so deployment and migration never have to be simultaneous.
Feature Flag
A runtime switch that decouples deploying code from releasing behaviour, so unfinished or risky work can ship dark.
Flag Debt
The accumulating complexity of feature flags that are never removed, producing untested code paths and combinatorial behaviour nobody understands.
Forced Upgrade
Blocking an installed client version from operating until it updates, which is the only lever available and is disruptive enough to need a policy.
Identity and Access Management
The system of record for principals, credentials and permissions, and the policy engine that decides what each principal may do.
Immutable Store Erasure Conflict
The direct contradiction between architectures designed never to forget and obligations requiring data to be removed, which must be resolved in the design rather than in policy.
InnerSource
Applying open-source collaboration practices inside an organisation, so that teams can contribute to code they do not own rather than waiting or duplicating.
Layered Architecture
Organising code into horizontal layers — presentation, application, domain, data — where each layer may only call the one beneath it.
Log Compaction
A retention policy that keeps only the most recent value for each key rather than deleting by age, so the log becomes a durable snapshot of current state.
Mesh Control Plane
The component that configures and coordinates a service mesh's data plane proxies, distributing policy, identity and routing rules.
Microsegmentation
Enforcing fine-grained network policy between individual workloads rather than between broad network zones, so a compromise cannot move laterally.
Namespace Tenancy
Isolating teams within a shared cluster by namespace plus quota plus network policy, and being explicit about what that does not isolate.
Observability
The property of being able to answer new questions about a system's internal state from its external outputs, without shipping new code.
Policy as Code
Encoding standards as automated admission and plan-time checks instead of review comments.
Code Review
Where architectural rules are enforced by people rather than by tools.
Infrastructure as Code
Declarative infrastructure, drift, state files and rebuild-from-empty.
AI Gateways
Centralised routing, keys, quotas, caching, logging and safety policy.
API Gateway
A single entry point for policy, routing and protocol translation.
APIs as Products
Ownership, lifecycle, deprecation policy and developer experience.
Application Performance Monitoring
Attributing latency to code paths, queries and dependencies.
Artifact Management
Immutable versioned outputs, promotion between repositories, and retention policy.
C4 Model
Context, container, component and code as four separate diagrams.
Cloud Governance
Preventive policy, tagging, quotas and cost and security guardrails.
Cost Governance
Budgets, anomaly alerts, quotas and preventive policy.
Design Patterns
Reusable solutions at code level, and when they become ceremony.
Documentation Practice
Keeping documents close to the code and honest about staleness.
Module Federation
Loading code from another build at runtime, with versioning and failure to think about.
Network Performance
Latency floors, bandwidth-delay product, and what no code change fixes.