DEV Community: Marco

Daily Dose of DevOps — Self-service platform: for enterprise software organizations

Marco — Sat, 07 Nov 2026 13:41:24 +0000

Self-service platform: for enterprise software organizations

A platform capability becomes dangerous when ownership is implicit but authority is broad. For self-service platform for enterprise software organizations, 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 self-service platform 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 self-service platform for enterprise software organizations, 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

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 self-service platform for enterprise software organizations, 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 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.

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 self-service platform as an owned product and control system, not a tool installation.
Design for the constraints captured by “for enterprise software organizations”; 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 — OpenTelemetry: without excessive logging overhead

Marco — Fri, 06 Nov 2026 14:44:13 +0000

OpenTelemetry: without excessive logging overhead

Enterprise reliability deteriorates when automation accelerates change without strengthening evidence. For opentelemetry without excessive logging overhead, 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 opentelemetry 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 opentelemetry without excessive logging overhead, 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

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 opentelemetry without excessive logging overhead, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

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.

Key Takeaways

Treat opentelemetry as an owned product and control system, not a tool installation.
Design for the constraints captured by “without excessive logging overhead”; 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 — Policy as code: for secure automation

Marco — Thu, 05 Nov 2026 15:05:59 +0000

Policy as code: for secure automation

A platform capability becomes dangerous when ownership is implicit but authority is broad. For policy as code for secure automation, 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 policy as code 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 policy as code for secure automation, 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 policy as code for secure automation, 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 policy as code as an owned product and control system, not a tool installation.
Design for the constraints captured by “for secure automation”; 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 scheduling: for observability-driven operations

Marco — Wed, 04 Nov 2026 14:59:52 +0000

Kubernetes scheduling: for observability-driven operations

Scale converts an informal convention into an outage mechanism. For kubernetes scheduling for observability-driven operations, 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 scheduling 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 scheduling for observability-driven operations, 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 scheduling for observability-driven operations, 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 scheduling as an owned product and control system, not a tool installation.
Design for the constraints captured by “for observability-driven operations”; 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 portal: for high-growth engineering teams

Marco — Tue, 03 Nov 2026 14:48:10 +0000

Developer portal: for high-growth engineering teams

The expensive failure is rarely the missing tool; it is the absent operating contract. For developer portal for high-growth engineering 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 developer portal 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 portal for high-growth engineering teams, 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 developer portal for high-growth engineering teams, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat developer portal as an owned product and control system, not a tool installation.
Design for the constraints captured by “for high-growth engineering teams”; 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 — Telemetry design: for platform operations teams

Marco — Mon, 02 Nov 2026 16:44:19 +0000

Telemetry design: for platform operations teams

Scale converts an informal convention into an outage mechanism. For telemetry design for platform operations 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 telemetry 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 telemetry design for platform operations teams, 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 telemetry design for platform operations teams, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat telemetry design as an owned product and control system, not a tool installation.
Design for the constraints captured by “for platform operations teams”; 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 — Workload identity: with federated identity

Marco — Sun, 01 Nov 2026 13:57:45 +0000

Workload identity: with federated identity

Enterprise reliability deteriorates when automation accelerates change without strengthening evidence. For workload identity with federated identity, 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 workload identity 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 workload identity with federated identity, 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 workload identity with federated identity, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat workload identity as an owned product and control system, not a tool installation.
Design for the constraints captured by “with federated identity”; 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 networking: for resilient workloads

Marco — Sat, 31 Oct 2026 13:14:55 +0000

Kubernetes networking: for resilient workloads

A platform capability becomes dangerous when ownership is implicit but authority is broad. For kubernetes networking for resilient 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 networking 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 networking for resilient workloads, 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 networking for resilient workloads, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat kubernetes networking as an owned product and control system, not a tool installation.
Design for the constraints captured by “for resilient 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 — Internal developer platform: for enterprise architecture teams

Marco — Fri, 30 Oct 2026 13:45:17 +0000

Internal developer platform: for enterprise architecture teams

Enterprise reliability deteriorates when automation accelerates change without strengthening evidence. For internal developer platform for enterprise architecture 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 internal developer platform 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 internal developer platform for enterprise architecture teams, 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 internal developer platform for enterprise architecture teams, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat internal developer platform as an owned product and control system, not a tool installation.
Design for the constraints captured by “for enterprise architecture teams”; 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 — Observability strategy: for engineering leadership

Marco — Thu, 29 Oct 2026 13:53:15 +0000

Observability strategy: for engineering leadership

Scale converts an informal convention into an outage mechanism. For observability strategy for engineering leadership, 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 observability strategy 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 observability strategy for engineering leadership, 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 observability strategy for engineering leadership, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat observability strategy as an owned product and control system, not a tool installation.
Design for the constraints captured by “for engineering leadership”; 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 — Identity and access: for compliance-heavy teams

Marco — Wed, 28 Oct 2026 13:43:37 +0000

Identity and access: for compliance-heavy teams

Enterprise reliability deteriorates when automation accelerates change without strengthening evidence. For identity and access for compliance-heavy 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 identity and access 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 identity and access for compliance-heavy teams, 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 identity and access for compliance-heavy teams, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat identity and access as an owned product and control system, not a tool installation.
Design for the constraints captured by “for compliance-heavy teams”; 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 architecture: for secure developer workloads

Marco — Tue, 27 Oct 2026 12:54:30 +0000

Kubernetes architecture: for secure developer workloads

Enterprise reliability deteriorates when automation accelerates change without strengthening evidence. For kubernetes architecture for secure developer 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 architecture 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 architecture for secure developer workloads, 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 architecture for secure developer workloads, prefer a small mandatory safety kernel surrounded by replaceable implementation choices.

What teams get wrong

Key Takeaways

Treat kubernetes architecture as an owned product and control system, not a tool installation.
Design for the constraints captured by “for secure developer 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.