5 min read - Self-Hosting Infrastructure: An Operations Decision Guide

Self-hosting trades vendor operations for your own. It can improve control over deployment, data location and recovery, but it does not make infrastructure free or automatically secure. This reference stack explains the decisions an engineering team must own before moving workloads away from managed platforms.

Define the service boundary first

Inventory the applications, databases, queues, public endpoints and internal tools in scope. For each one, record its owner, data class, recovery target and acceptable downtime. A self-hosting decision without those inputs is only a preference.

A common small-team stack may include:

This is a menu, not a recommended bill of materials. Each additional component creates another upgrade path, credential set and failure mode.

Deployment begins after a successful build

Coolify is an open-source, self-hostable control plane that deploys Docker workloads on infrastructure you provide. Its documentation covers Git-based deployments, Dockerfiles, Compose, health checks and resource limits. That removes some repetitive deployment work, but the server, network, backups and incident response remain yours.

A production release should have:

• an immutable image or reproducible build
• a readiness check that tests the application's real dependencies
• a rollback procedure that has been exercised
• resource limits based on observed demand
• separation between preview, staging and production credentials

Do not promise zero downtime merely because a platform offers rolling updates. The result depends on health checks, state handling, database changes and available capacity.

Alert on user impact, not arbitrary numbers

Prometheus stores time-series metrics and evaluates alerting rules; Grafana can present metrics and logs. The tools do not decide which thresholds are correct. Derive them from service objectives and measured baselines.

For example, a latency alert should reflect the response time users experience on a specific route. A disk alert should leave enough time for a person or automated cleanup to act. Review false positives and missed incidents, then change the rule. Fixed thresholds copied from another stack are not evidence.

Logs require their own decisions: retention, access, redaction and correlation identifiers. Avoid sending secrets, session tokens or unnecessary personal data into a central log store.

Local model serving needs an evaluation case

Ollama exposes a local API for running supported models. Keeping inference on infrastructure you control can change the data path and remove a per-request external API call. It does not prove that the data is safe, the model is fast enough or its answers are accurate.

Measure each proposed task on the intended hardware. Record output quality, latency, concurrency, memory use, energy and operator time. Model size alone does not predict whether code review, summarization or extraction will meet the requirement. Retain a managed or manual fallback for workloads that fail the test.

Network controls reduce exposure; they do not erase risk

Cloudflare documents that its Tunnel connector creates outbound-only connections and can expose services without a publicly routable origin IP. Private-network products can also restrict internal access by identity. These controls are useful, but neither is a complete security architecture.

You still need to manage:

• identity lifecycle and least privilege
• application authentication and authorization
• host and container patching
• secret rotation
• dependency and image provenance
• audit logs and incident response

Describe the resulting design by its controls. Do not call it “zero trust” merely because it uses a VPN, tunnel or identity proxy.

A backup is not a recovery plan

Choose backup frequency and retention from recovery requirements, not a generic schedule. Keep at least one protected copy outside the primary failure domain. Encrypt sensitive backups, restrict access and monitor failed jobs.

Most importantly, test restoration into a clean environment. Measure how long it takes, verify application behavior and record gaps. A successful upload only proves that a file was written; it does not prove that the service can be recovered.

Compare costs with current evidence

Cloud and SaaS prices change, and two stacks seldom include the same reliability or support. Build the comparison from current invoices and quotes. Include compute, storage, egress, backup, monitoring, licences, security tooling and engineering time. Also include planned maintenance and incident work.

Self-hosting is a sound choice when the control gained is worth those responsibilities and the team can operate the system. Otherwise, a managed service or hybrid design is safer. Revisit the calculation when workload, staffing or vendor terms change.

Sources reviewed

• Coolify application documentation, reviewed 27 August 2026
• Coolify health checks, reviewed 27 August 2026
• Prometheus overview, reviewed 27 August 2026
• Ollama API introduction, reviewed 27 August 2026
• Cloudflare connectivity options, reviewed 27 August 2026