Deployment Anti-Patterns

Introduction

Deployment failures are rarely caused by a single bad commit. They are usually systemic: hidden coupling, manual steps, and inconsistent artifacts. This post catalogs anti-patterns that advanced teams should eliminate to keep deployment throughput high and risk low.

Anti-Pattern 1: Mutable Artifacts

Building a new artifact for each environment invalidates test results. A single immutable artifact should be promoted through environments with only configuration changes applied at runtime.

Anti-Pattern 2: SSH-Based Manual Deployments

Manual shell access breaks auditability and makes rollbacks unpredictable. Replace it with declarative deployment tools and tracked releases.

Anti-Pattern 3: Environment-Specific Branches

Branch-per-environment introduces merge conflicts and hidden drift. Use a single mainline and environment-specific configuration managed via sealed secrets and runtime settings.

Anti-Pattern 4: Configuration in Code

Hard-coded environment values lead to repeated redeployments and secrets exposure. Configuration should be externalized and injected at deployment time.

public sealed class DbOptions
{
    public string ConnectionString { get; init; } = string.Empty;
}

builder.Services.Configure<DbOptions>(
    builder.Configuration.GetSection("Database"));

The configuration values can now come from environment variables or a secret manager, not from a code change.

Anti-Pattern 5: Big-Bang Releases

Large releases reduce observability and make rollbacks dangerous. Progressive delivery, canary releases, and feature flags reduce impact radius.

Anti-Pattern 6: Ignoring Runtime Signals

Deployments should be gated on runtime telemetry. A release pipeline that ignores error rates and latency is equivalent to flying blind.

Replacement Patterns

• Immutable artifacts with promotion-based deployment.
• Infrastructure as Code for environments.
• Progressive delivery with automated health checks.
• Audit trails for every release action.

Summary

Eliminating deployment anti-patterns is mostly about consistency: build once, deploy consistently, and drive decisions using runtime signals. The payoff is lower change failure rate and faster incident recovery.