Kubernetes Is Not Your Architecture
How to separate deployment mechanics from service boundaries, failure domains, and product ownership.
A scheduler can run almost any topology. That does not make the topology coherent, resilient, or easy to own.
EXECUTIVE THESIS
Kubernetes schedules workloads; it does not decide service boundaries, data ownership, product ownership, or failure semantics. Those architectural decisions must be coherent before deployment objects can make the system reliable.
Model the service first
Define ownership, contracts, data responsibility, scaling behavior, and failure expectations before choosing pods, probes, or autoscaling policy.
Make operations boring
Standardize telemetry, health semantics, safe rollout policy, resource envelopes, and incident runbooks so teams can focus on business behavior.
Align failure domains
A deployment boundary should reflect how the product fails and who responds. Splitting one transaction across many independently deployed services increases coordination and recovery cost; combining unrelated scaling profiles creates noisy-neighbor risk. Use those tradeoffs, not fashion, to draw boundaries.
Keep platform policy paved
Golden paths should package secure base images, identity, telemetry, rollout defaults, and cost labels while leaving domain logic to the product team. The platform becomes leverage when the safe choice is also the shortest path to production.
SYSTEM DESIGN
Decision framework
Draw ownership before pods
A service boundary should align a business capability, its data, the team that changes it, and the team that responds when it fails. A deployment boundary created only for technical fashion increases coordination cost.
Align scaling and failure
Separate components when they have materially different scaling profiles, security boundaries, release cadence, or failure impact. Keep them together when a distributed transaction would create more risk than independent deployment removes.
Standardize the platform contract
Health semantics, identity, telemetry, rollout strategy, resource envelopes, and incident ownership should be delivered through a paved path rather than recreated in every repository.
FROM DESIGN TO DELIVERY
Implementation playbook
- 1
Model the workload
Document dependencies, state, startup behavior, graceful shutdown, capacity, and availability targets before writing manifests.
- 2
Design health correctly
Readiness should remove a pod that cannot serve; liveness should restart only an unrecoverable process. Startup probes must reflect initialization without masking permanent failure.
- 3
Make rollout observable
Connect deployment events to latency, errors, saturation, and business outcomes. Use canaries or progressive delivery where failure impact justifies the operational cost.
- 4
Practice node and region loss
Validate disruption budgets, topology spread, data recovery, queue backlog behavior, and capacity headroom under realistic infrastructure failure.
Production review
Use these two lists during architecture review, readiness assessment, and post-incident learning.
COMMON FAILURE MODES
- Splitting a monolith without changing ownership or data coupling
- Using probes that always return success
- Autoscaling on CPU while the real bottleneck is a downstream dependency
READINESS CHECKLIST
- Explicit service and data ownership
- Resource requests based on measurement
- Correct readiness, liveness, and startup semantics
- Progressive rollout with business signals
- Tested disruption and recovery plan