DEV Community: Marco

Daily Dose of DevOps — SLI definition: without alert fatigue

Marco — Sat, 17 Oct 2026 11:17:59 +0000

SLI definition: without alert fatigue

A platform capability becomes dangerous when ownership is implicit but authority is broad. For sli definition without alert fatigue, the decisive question is not whether a team can demonstrate the technology once. It is whether the organisation can operate it repeatedly, audit its decisions, and recover when assumptions fail.

The operating problem

Treat sli definition as part of an SLO-led telemetry platform that connects service behaviour to customer-visible outcomes. Define the consumer, owner, support boundary, change policy, and recovery objective before selecting implementation details. When operating sli definition without alert fatigue, undocumented authority and ambiguous ownership create more risk than a missing feature.

A credible design measures error-budget burn, tail latency, cardinality growth, telemetry loss, and diagnostic time. Those measures should be visible to both the platform owner and consuming teams. If the measurements cannot distinguish adoption from coercion, or reliability from mere activity, the operating model is not yet falsifiable.

A practical control

Start with a narrow contract that can be tested automatically. The implementation should encode stable semantic conventions, tiered retention, cardinality budgets, sampling policy, and telemetry pipeline SLOs. The following fragment is illustrative; production values must be derived from workload evidence and organisational policy.

processors:
  memory_limiter:
    limit_mib: 512
  batch:
    send_batch_size: 1024
exporters:
  otlp:
    endpoint: telemetry-gateway:4317

Roll the control out to one representative service, observe failure behaviour, and exercise rollback before broad adoption. Record exceptions as expiring decisions with an accountable owner, not permanent bypasses.

Trade-offs

Standardisation reduces cognitive load and makes controls observable, but an excessively rigid path displaces complexity into workarounds. Flexibility improves local fit, but every variant expands the support surface and weakens fleet-wide guarantees. For sli definition without alert fatigue, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

The organisation must also pay for operability. More validation increases feedback time; more telemetry increases cost and cardinality risk; stronger isolation can reduce utilisation. Make those costs explicit and compare them with the blast radius and recovery cost they buy down.

What teams get wrong

The recurrent anti-pattern is collecting every available signal without ownership, retention economics, or an incident hypothesis. Teams then measure task completion instead of production outcomes, accumulate exceptions without expiry, and discover during an incident that the nominal control has no tested recovery path.

Another error is adopting a reference architecture without its assumptions. Validate identity boundaries, dependency failure, capacity pressure, partial rollout, rollback, and audit reconstruction in the environment that will actually carry production traffic.

Key Takeaways

Treat sli definition as an owned product and control system, not a tool installation.
Design for the constraints captured by “without alert fatigue”; document the authority, failure domain, and recovery objective.
Measure error-budget burn, tail latency, cardinality growth, telemetry loss, and diagnostic time.
Automate stable semantic conventions, tiered retention, cardinality budgets, sampling policy, and telemetry pipeline SLOs.
Test degraded operation and rollback before scaling adoption.

Daily Dose of DevOps — Container security: with least privilege by default

Marco — Fri, 16 Oct 2026 12:02:43 +0000

Container security: with least privilege by default

Enterprise reliability deteriorates when automation accelerates change without strengthening evidence. For container security with least privilege by default, the decisive question is not whether a team can demonstrate the technology once. It is whether the organisation can operate it repeatedly, audit its decisions, and recover when assumptions fail.

The operating problem

Treat container security as part of a zero-trust delivery system in which identity, provenance, and policy are evaluated continuously. Define the consumer, owner, support boundary, change policy, and recovery objective before selecting implementation details. When operating container security with least privilege by default, undocumented authority and ambiguous ownership create more risk than a missing feature.

A credible design measures control coverage, policy exceptions, credential lifetime, remediation latency, and provenance verification. Those measures should be visible to both the platform owner and consuming teams. If the measurements cannot distinguish adoption from coercion, or reliability from mere activity, the operating model is not yet falsifiable.

A practical control

Start with a narrow contract that can be tested automatically. The implementation should encode short-lived identity, least privilege, immutable dependencies, signed provenance, and policy-as-code enforcement. The following fragment is illustrative; production values must be derived from workload evidence and organisational policy.

permissions:
  contents: read
  id-token: write
steps:
  - uses: actions/checkout@<immutable-sha>
  - run: cosign verify --certificate-identity-regexp='^https://github.com/example/' artifact

Trade-offs

Standardisation reduces cognitive load and makes controls observable, but an excessively rigid path displaces complexity into workarounds. Flexibility improves local fit, but every variant expands the support surface and weakens fleet-wide guarantees. For container security with least privilege by default, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

The recurrent anti-pattern is adding ceremonial approval gates without constraining capabilities or verifying the produced artifact. Teams then measure task completion instead of production outcomes, accumulate exceptions without expiry, and discover during an incident that the nominal control has no tested recovery path.

Key Takeaways

Treat container security as an owned product and control system, not a tool installation.
Design for the constraints captured by “with least privilege by default”; document the authority, failure domain, and recovery objective.
Measure control coverage, policy exceptions, credential lifetime, remediation latency, and provenance verification.
Automate short-lived identity, least privilege, immutable dependencies, signed provenance, and policy-as-code enforcement.
Test degraded operation and rollback before scaling adoption.

Daily Dose of DevOps — Kubernetes observability: for regulated workloads

Marco — Thu, 15 Oct 2026 12:22:47 +0000

Kubernetes observability: for regulated workloads

Scale converts an informal convention into an outage mechanism. For kubernetes observability for regulated workloads, the decisive question is not whether a team can demonstrate the technology once. It is whether the organisation can operate it repeatedly, audit its decisions, and recover when assumptions fail.

The operating problem

Treat kubernetes observability as part of a multi-tenant Kubernetes platform with declarative reconciliation and bounded workload privileges. Define the consumer, owner, support boundary, change policy, and recovery objective before selecting implementation details. When operating kubernetes observability for regulated workloads, undocumented authority and ambiguous ownership create more risk than a missing feature.

A credible design measures saturation, scheduling latency, error-budget burn, reconciliation failure, and recovery time. Those measures should be visible to both the platform owner and consuming teams. If the measurements cannot distinguish adoption from coercion, or reliability from mere activity, the operating model is not yet falsifiable.

A practical control

Start with a narrow contract that can be tested automatically. The implementation should encode tested admission policy, workload identity, resource envelopes, progressive delivery, and explicit tenancy boundaries. The following fragment is illustrative; production values must be derived from workload evidence and organisational policy.

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: critical-api
spec:
  minAvailable: 80%
  selector:
    matchLabels:
      app: critical-api

Trade-offs

Standardisation reduces cognitive load and makes controls observable, but an excessively rigid path displaces complexity into workarounds. Flexibility improves local fit, but every variant expands the support surface and weakens fleet-wide guarantees. For kubernetes observability for regulated workloads, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

The recurrent anti-pattern is treating Kubernetes defaults as an operating model and allowing every team to invent cluster policy. Teams then measure task completion instead of production outcomes, accumulate exceptions without expiry, and discover during an incident that the nominal control has no tested recovery path.

Key Takeaways

Treat kubernetes observability as an owned product and control system, not a tool installation.
Design for the constraints captured by “for regulated workloads”; document the authority, failure domain, and recovery objective.
Measure saturation, scheduling latency, error-budget burn, reconciliation failure, and recovery time.
Automate tested admission policy, workload identity, resource envelopes, progressive delivery, and explicit tenancy boundaries.
Test degraded operation and rollback before scaling adoption.

Daily Dose of DevOps — Developer experience: with strong SRE collaboration

Marco — Wed, 14 Oct 2026 12:36:01 +0000

Developer experience: with strong SRE collaboration

A platform capability becomes dangerous when ownership is implicit but authority is broad. For developer experience with strong SRE collaboration, the decisive question is not whether a team can demonstrate the technology once. It is whether the organisation can operate it repeatedly, audit its decisions, and recover when assumptions fail.

The operating problem

Treat developer experience as part of a product-oriented internal platform with explicit service ownership and paved-road contracts. Define the consumer, owner, support boundary, change policy, and recovery objective before selecting implementation details. When operating developer experience with strong SRE collaboration, undocumented authority and ambiguous ownership create more risk than a missing feature.

A credible design measures adoption, successful self-service completion, lead time, and platform-induced toil. Those measures should be visible to both the platform owner and consuming teams. If the measurements cannot distinguish adoption from coercion, or reliability from mere activity, the operating model is not yet falsifiable.

A practical control

Start with a narrow contract that can be tested automatically. The implementation should encode versioned golden paths, discoverable ownership, policy guardrails, and measured developer outcomes. The following fragment is illustrative; production values must be derived from workload evidence and organisational policy.

apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
  name: payments-api
  annotations:
    platform.example/owner: payments
spec:
  type: service
  lifecycle: production

Trade-offs

Standardisation reduces cognitive load and makes controls observable, but an excessively rigid path displaces complexity into workarounds. Flexibility improves local fit, but every variant expands the support surface and weakens fleet-wide guarantees. For developer experience with strong SRE collaboration, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

The recurrent anti-pattern is centralising delivery behind a ticket queue while calling the result self-service. Teams then measure task completion instead of production outcomes, accumulate exceptions without expiry, and discover during an incident that the nominal control has no tested recovery path.

Key Takeaways

Treat developer experience as an owned product and control system, not a tool installation.
Design for the constraints captured by “with strong SRE collaboration”; document the authority, failure domain, and recovery objective.
Measure adoption, successful self-service completion, lead time, and platform-induced toil.
Automate versioned golden paths, discoverable ownership, policy guardrails, and measured developer outcomes.
Test degraded operation and rollback before scaling adoption.

Daily Dose of DevOps — SLO design: for high-change environments

Marco — Tue, 13 Oct 2026 14:44:01 +0000

SLO design: for high-change environments

A platform capability becomes dangerous when ownership is implicit but authority is broad. For slo design for high-change environments, the decisive question is not whether a team can demonstrate the technology once. It is whether the organisation can operate it repeatedly, audit its decisions, and recover when assumptions fail.

The operating problem

Treat slo design as part of an SLO-led telemetry platform that connects service behaviour to customer-visible outcomes. Define the consumer, owner, support boundary, change policy, and recovery objective before selecting implementation details. When operating slo design for high-change environments, undocumented authority and ambiguous ownership create more risk than a missing feature.

A practical control

processors:
  memory_limiter:
    limit_mib: 512
  batch:
    send_batch_size: 1024
exporters:
  otlp:
    endpoint: telemetry-gateway:4317

Trade-offs

Standardisation reduces cognitive load and makes controls observable, but an excessively rigid path displaces complexity into workarounds. Flexibility improves local fit, but every variant expands the support surface and weakens fleet-wide guarantees. For slo design for high-change environments, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat slo design as an owned product and control system, not a tool installation.
Design for the constraints captured by “for high-change environments”; document the authority, failure domain, and recovery objective.
Measure error-budget burn, tail latency, cardinality growth, telemetry loss, and diagnostic time.
Automate stable semantic conventions, tiered retention, cardinality budgets, sampling policy, and telemetry pipeline SLOs.
Test degraded operation and rollback before scaling adoption.

Daily Dose of DevOps — Supply chain security: for application security leaders

Marco — Mon, 12 Oct 2026 16:23:22 +0000

Supply chain security: for application security leaders

Enterprise reliability deteriorates when automation accelerates change without strengthening evidence. For supply chain security for application security leaders, the decisive question is not whether a team can demonstrate the technology once. It is whether the organisation can operate it repeatedly, audit its decisions, and recover when assumptions fail.

The operating problem

Treat supply chain security as part of a zero-trust delivery system in which identity, provenance, and policy are evaluated continuously. Define the consumer, owner, support boundary, change policy, and recovery objective before selecting implementation details. When operating supply chain security for application security leaders, undocumented authority and ambiguous ownership create more risk than a missing feature.

A practical control

permissions:
  contents: read
  id-token: write
steps:
  - uses: actions/checkout@<immutable-sha>
  - run: cosign verify --certificate-identity-regexp='^https://github.com/example/' artifact

Trade-offs

Standardisation reduces cognitive load and makes controls observable, but an excessively rigid path displaces complexity into workarounds. Flexibility improves local fit, but every variant expands the support surface and weakens fleet-wide guarantees. For supply chain security for application security leaders, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat supply chain security as an owned product and control system, not a tool installation.
Design for the constraints captured by “for application security leaders”; document the authority, failure domain, and recovery objective.
Measure control coverage, policy exceptions, credential lifetime, remediation latency, and provenance verification.
Automate short-lived identity, least privilege, immutable dependencies, signed provenance, and policy-as-code enforcement.
Test degraded operation and rollback before scaling adoption.

Daily Dose of DevOps — Kubernetes storage: for application teams

Marco — Sun, 11 Oct 2026 13:42:44 +0000

Kubernetes storage: for application teams

The expensive failure is rarely the missing tool; it is the absent operating contract. For kubernetes storage for application teams, the decisive question is not whether a team can demonstrate the technology once. It is whether the organisation can operate it repeatedly, audit its decisions, and recover when assumptions fail.

The operating problem

Treat kubernetes storage as part of a multi-tenant Kubernetes platform with declarative reconciliation and bounded workload privileges. Define the consumer, owner, support boundary, change policy, and recovery objective before selecting implementation details. When operating kubernetes storage for application teams, undocumented authority and ambiguous ownership create more risk than a missing feature.

A practical control

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: critical-api
spec:
  minAvailable: 80%
  selector:
    matchLabels:
      app: critical-api

Trade-offs

Standardisation reduces cognitive load and makes controls observable, but an excessively rigid path displaces complexity into workarounds. Flexibility improves local fit, but every variant expands the support surface and weakens fleet-wide guarantees. For kubernetes storage for application teams, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat kubernetes storage as an owned product and control system, not a tool installation.
Design for the constraints captured by “for application teams”; document the authority, failure domain, and recovery objective.
Measure saturation, scheduling latency, error-budget burn, reconciliation failure, and recovery time.
Automate tested admission policy, workload identity, resource envelopes, progressive delivery, and explicit tenancy boundaries.
Test degraded operation and rollback before scaling adoption.

Daily Dose of DevOps — Platform governance: without creating platform sprawl

Marco — Sat, 10 Oct 2026 13:12:19 +0000

Platform governance: without creating platform sprawl

The expensive failure is rarely the missing tool; it is the absent operating contract. For platform governance without creating platform sprawl, the decisive question is not whether a team can demonstrate the technology once. It is whether the organisation can operate it repeatedly, audit its decisions, and recover when assumptions fail.

The operating problem

Treat platform governance as part of a product-oriented internal platform with explicit service ownership and paved-road contracts. Define the consumer, owner, support boundary, change policy, and recovery objective before selecting implementation details. When operating platform governance without creating platform sprawl, undocumented authority and ambiguous ownership create more risk than a missing feature.

A practical control

apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
  name: payments-api
  annotations:
    platform.example/owner: payments
spec:
  type: service
  lifecycle: production

Trade-offs

Standardisation reduces cognitive load and makes controls observable, but an excessively rigid path displaces complexity into workarounds. Flexibility improves local fit, but every variant expands the support surface and weakens fleet-wide guarantees. For platform governance without creating platform sprawl, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat platform governance as an owned product and control system, not a tool installation.
Design for the constraints captured by “without creating platform sprawl”; document the authority, failure domain, and recovery objective.
Measure adoption, successful self-service completion, lead time, and platform-induced toil.
Automate versioned golden paths, discoverable ownership, policy guardrails, and measured developer outcomes.
Test degraded operation and rollback before scaling adoption.

Daily Dose of DevOps — Log pipeline: for platform adoption programs

Marco — Fri, 09 Oct 2026 14:03:05 +0000

Log pipeline: for platform adoption programs

Scale converts an informal convention into an outage mechanism. For log pipeline for platform adoption programs, the decisive question is not whether a team can demonstrate the technology once. It is whether the organisation can operate it repeatedly, audit its decisions, and recover when assumptions fail.

The operating problem

Treat log pipeline as part of an SLO-led telemetry platform that connects service behaviour to customer-visible outcomes. Define the consumer, owner, support boundary, change policy, and recovery objective before selecting implementation details. When operating log pipeline for platform adoption programs, undocumented authority and ambiguous ownership create more risk than a missing feature.

A practical control

processors:
  memory_limiter:
    limit_mib: 512
  batch:
    send_batch_size: 1024
exporters:
  otlp:
    endpoint: telemetry-gateway:4317

Trade-offs

Standardisation reduces cognitive load and makes controls observable, but an excessively rigid path displaces complexity into workarounds. Flexibility improves local fit, but every variant expands the support surface and weakens fleet-wide guarantees. For log pipeline for platform adoption programs, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat log pipeline as an owned product and control system, not a tool installation.
Design for the constraints captured by “for platform adoption programs”; document the authority, failure domain, and recovery objective.
Measure error-budget burn, tail latency, cardinality growth, telemetry loss, and diagnostic time.
Automate stable semantic conventions, tiered retention, cardinality budgets, sampling policy, and telemetry pipeline SLOs.
Test degraded operation and rollback before scaling adoption.

Daily Dose of DevOps — Zero trust: for security reviews

Marco — Thu, 08 Oct 2026 14:18:38 +0000

Zero trust: for security reviews

The expensive failure is rarely the missing tool; it is the absent operating contract. For zero trust for security reviews, the decisive question is not whether a team can demonstrate the technology once. It is whether the organisation can operate it repeatedly, audit its decisions, and recover when assumptions fail.

The operating problem

Treat zero trust as part of a zero-trust delivery system in which identity, provenance, and policy are evaluated continuously. Define the consumer, owner, support boundary, change policy, and recovery objective before selecting implementation details. When operating zero trust for security reviews, undocumented authority and ambiguous ownership create more risk than a missing feature.

A practical control

permissions:
  contents: read
  id-token: write
steps:
  - uses: actions/checkout@<immutable-sha>
  - run: cosign verify --certificate-identity-regexp='^https://github.com/example/' artifact

Trade-offs

Standardisation reduces cognitive load and makes controls observable, but an excessively rigid path displaces complexity into workarounds. Flexibility improves local fit, but every variant expands the support surface and weakens fleet-wide guarantees. For zero trust for security reviews, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat zero trust as an owned product and control system, not a tool installation.
Design for the constraints captured by “for security reviews”; document the authority, failure domain, and recovery objective.
Measure control coverage, policy exceptions, credential lifetime, remediation latency, and provenance verification.
Automate short-lived identity, least privilege, immutable dependencies, signed provenance, and policy-as-code enforcement.
Test degraded operation and rollback before scaling adoption.

Daily Dose of DevOps — Cluster lifecycle: for cost-conscious clusters

Marco — Wed, 07 Oct 2026 14:08:13 +0000

Cluster lifecycle: for cost-conscious clusters

A platform capability becomes dangerous when ownership is implicit but authority is broad. For cluster lifecycle for cost-conscious clusters, the decisive question is not whether a team can demonstrate the technology once. It is whether the organisation can operate it repeatedly, audit its decisions, and recover when assumptions fail.

The operating problem

Treat cluster lifecycle as part of a multi-tenant Kubernetes platform with declarative reconciliation and bounded workload privileges. Define the consumer, owner, support boundary, change policy, and recovery objective before selecting implementation details. When operating cluster lifecycle for cost-conscious clusters, undocumented authority and ambiguous ownership create more risk than a missing feature.

A practical control

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: critical-api
spec:
  minAvailable: 80%
  selector:
    matchLabels:
      app: critical-api

Trade-offs

Standardisation reduces cognitive load and makes controls observable, but an excessively rigid path displaces complexity into workarounds. Flexibility improves local fit, but every variant expands the support surface and weakens fleet-wide guarantees. For cluster lifecycle for cost-conscious clusters, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat cluster lifecycle as an owned product and control system, not a tool installation.
Design for the constraints captured by “for cost-conscious clusters”; document the authority, failure domain, and recovery objective.
Measure saturation, scheduling latency, error-budget burn, reconciliation failure, and recovery time.
Automate tested admission policy, workload identity, resource envelopes, progressive delivery, and explicit tenancy boundaries.
Test degraded operation and rollback before scaling adoption.

Daily Dose of DevOps — Platform capability: with strong change governance

Marco — Tue, 06 Oct 2026 13:50:34 +0000

Platform capability: with strong change governance

The expensive failure is rarely the missing tool; it is the absent operating contract. For platform capability with strong change governance, the decisive question is not whether a team can demonstrate the technology once. It is whether the organisation can operate it repeatedly, audit its decisions, and recover when assumptions fail.

The operating problem

Treat platform capability as part of a product-oriented internal platform with explicit service ownership and paved-road contracts. Define the consumer, owner, support boundary, change policy, and recovery objective before selecting implementation details. When operating platform capability with strong change governance, undocumented authority and ambiguous ownership create more risk than a missing feature.

A practical control

apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
  name: payments-api
  annotations:
    platform.example/owner: payments
spec:
  type: service
  lifecycle: production

Trade-offs

Standardisation reduces cognitive load and makes controls observable, but an excessively rigid path displaces complexity into workarounds. Flexibility improves local fit, but every variant expands the support surface and weakens fleet-wide guarantees. For platform capability with strong change governance, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat platform capability as an owned product and control system, not a tool installation.
Design for the constraints captured by “with strong change governance”; document the authority, failure domain, and recovery objective.
Measure adoption, successful self-service completion, lead time, and platform-induced toil.
Automate versioned golden paths, discoverable ownership, policy guardrails, and measured developer outcomes.
Test degraded operation and rollback before scaling adoption.