# Benefits of Using Dewy Over Manual Deployments: 12 Production Advantages > Discover the 12 production advantages of Dewy over manual deployments. Automate versioning, caching, zero-downtime updates, and rollbacks with this pull-based workflow. - Repository: [Tomohisa Oda/dewy](https://github.com/linyows/dewy) - Tags: best-practices - Published: 2026-03-06 --- **Dewy replaces fragile deployment scripts with a declarative, pull-based workflow that automates version detection, artifact caching, zero-downtime updates, and rollback handling through a single Go-native binary.** Manual deployments rely on ad-hoc scripts and cron jobs that break silently and lack rollback safety. Dewy, the open-source Go-native deployment engine from `linyows/dewy`, eliminates this operational debt by isolating *what* should be deployed from *how* it is delivered. Understanding the specific benefits of using Dewy over manual deployments requires examining its source-level implementation of caching, health checks, and declarative configuration. ## Unified Declarative Configuration Dewy uses a single **declarative model** to drive binary, static-asset, or container deployments. The `Config` struct defined in [`dewy.go`](https://github.com/linyows/dewy/blob/main/dewy.go) (lines 46-73) holds the registry URL, command type (`SERVER`, `ASSETS`, `CONTAINER`), and optional slot configuration for blue/green deployments according to the `linyows/dewy` source code. This eliminates the need to maintain separate bash scripts for different artifact types. ### Automatic Semantic Version Detection Unlike manual scripts that download artifacts blindly, Dewy's `registry.Current()` function (dewy.go, lines 52-80) queries the registry for the latest semantic version tag. Dewy compares this with the cached `current` key stored via `kvs.File` and skips the entire deployment pipeline if the version is already present. This prevents unnecessary network traffic and service restarts. ## Artifact Caching and Rollback Safety **Local artifact caching** ensures deployments remain fast and repeatable as implemented in `linyows/dewy`. The `kvs.File` implementation (dewy.go, lines 80-94) stores downloaded artifacts locally using `cachekeyName`, creating atomic links to the release directory. If a rollback is required, Dewy immediately points back to the previous cached artifact without re-downloading. ## Zero-Downtime Rolling Updates for Containers Manual container updates often cause connection drops. Dewy's `deployContainer` function (dewy.go, lines 445-515) orchestrates zero-downtime deployments by starting new containers before stopping old ones. A built-in TCP proxy routes traffic to the healthy replica only after verification. ### Built-in Health Checks and Automatic Rollback The `createHealthCheckFunc` injector (dewy.go, lines 886-918) continuously monitors new containers. If the health check fails, Dewy executes an automatic rollback path that stops and removes the new container while leaving the previous version untouched, eliminating the risk of failed deployments staying in production. ### Blue/Green Slot Support Dewy supports **build-metadata slots** (`+blue`, `+green`) to target specific deployment groups. The slot matching logic in `Run` and `RunContainer` (dewy.go, lines 71-78) skips deployment when the artifact slot does not match the instance configuration, enabling safe canary releases across server fleets. ## Extensible Registry and Notification System ### Pluggable Artifact Registries Dewy abstracts registry access through a common `Registry` interface. The `registry.New` factory function ([`registry/registry.go`](https://github.com/linyows/dewy/blob/main/registry/registry.go), lines 20-45) parses URL schemes—including `ghr://` for GitHub Releases, `s3://` for AWS S3, `img://` for OCI registries, and gRPC endpoints—to return the appropriate implementation. This eliminates vendor lock-in and allows artifact migration without changing deployment logic. ### Automated Notification Hooks The notification system uses `notifier.New` to initialize Slack, email, or custom webhooks. The `execHook` function (dewy.go, lines 6-19) runs user-provided shell commands at deployment start, success, failure, and error events, with built-in throttling to prevent alert spam. ## Observability and Operational Control ### Structured Logging and Admin API All internal events flow through Go's `slog` package with optional JSON output for log aggregation pipelines ([`cmd/dewy/main.go`](https://github.com/linyows/dewy/blob/main/cmd/dewy/main.go), lines 30-38). The `startAdminAPI` function (dewy.go, lines 303-340) exposes HTTP endpoints at `/api/status` and `/api/containers` to report current versions, proxy backend counts, and running container lists for real-time dashboards. ### Graceful Signal Handling The `waitSigs` goroutine (dewy.go, lines 93-136) manages process signals: `SIGUSR1` triggers a zero-downtime server restart without dropping connections, while `SIGTERM` gracefully stops managed containers and cleans up resources. ## Self-Contained Deployment Binary Dewy compiles to a **single static binary** via `go build ./cmd/dewy` (`Makefile`, lines 1-4) with no external runtime dependencies beyond the compiled Go runtime. This eliminates "works on my machine" scenarios and simplifies installation to a single file copy. ## Practical Deployment Examples Deploy a binary application with Slack notifications: ```bash dewy server \ --registry ghr://myorg/myapp \ --notifier slack://ops?title=myapp \ -p 8000 -l info \ -- /opt/myapp/current/myapp ``` Deploy static assets to a web root: ```bash dewy assets \ --registry ghr://myorg/frontend \ -d /var/www/html \ -l info ``` Zero-downtime container deployment with auto-detected port: ```bash dewy container \ --registry img://ghcr.io/myorg/webapp \ --port 8080 \ --replicas 3 \ -- -e DATABASE_URL=postgres://db:5432/app ``` Execute a pre-deploy database backup hook: ```bash dewy server \ --registry ghr://myorg/api \ --before-deploy-hook "pg_dump main > /backup/$(date +%Y%m%d_%H%M%S).sql" \ -- /opt/api/current/api ``` Target a specific blue/green slot: ```bash dewy server \ --registry ghr://myorg/api \ --slot green \ -- /opt/api/current/api ``` ## Summary - **Declarative configuration** in [`dewy.go`](https://github.com/linyows/dewy/blob/main/dewy.go) unifies server, asset, and container deployments under one model. - **Semantic version detection** via `registry.Current()` prevents redundant deployments. - **Atomic artifact caching** with `kvs.File` guarantees fast rollbacks and offline capability. - **Zero-downtime updates** use `deployContainer` with built-in TCP proxying and health checks. - **Automatic rollback** triggered by `createHealthCheckFunc` failures protects production stability. - **Pluggable registries** via `registry.New` support GitHub Releases, S3, OCI, and gRPC without code changes. - **Self-contained binary** deployment eliminates runtime dependencies and installation complexity. ## Frequently Asked Questions ### How does Dewy prevent deploying the same version twice? Dewy caches the current release tag using `kvs.File` and compares it against the latest version returned by `registry.Current()` before initiating any download or restart sequence. The deployment is skipped entirely if the versions match, preventing unnecessary service interruptions. ### What happens if a new container fails its health check? The `createHealthCheckFunc` injected into `deployContainer` monitors the new container continuously. On failure, Dewy automatically stops and removes the faulty container while keeping the previous version running, effectively performing a zero-touch rollback without manual intervention. ### Can Dewy deploy artifacts from private S3 buckets or GitHub Enterprise? Yes, the `registry.New` factory supports multiple URL schemes including `s3://` for AWS S3, `ghr://` for GitHub Releases, and OCI registries via `img://`. Authentication is handled through environment variables or standard credential chains for each provider. ### How does Dewy handle zero-downtime updates without a load balancer? Dewy implements a built-in TCP proxy that routes incoming connections to healthy containers. During `deployContainer` execution, the new container starts and joins the proxy backend pool before the old container receives termination signals. This ensures continuous availability without requiring external load balancers.