Back to all posts
DevOps7 min read·October 25, 2026

Managed Services vs Self-Hosting: What Should You Choose?

TB
ThynkBlox Team
Engineering

Should you choose managed services or self-hosting?

Choose managed services when the provider's responsibilities cover work your team cannot reliably operate, and its limits fit your product. Choose self-hosting when you need specific control and have people who can maintain, monitor and recover the system. The useful comparison is the operational work, control and ongoing cost you accept with each option.

Start with a practical question: who will restore service when something breaks outside working hours?

What are you actually choosing to manage?

For this comparison, a managed service means a provider operates a defined part of your software infrastructure. Self-hosting means your team operates that component, whether it runs on rented infrastructure or equipment you own.

Treat “managed” as the start of a responsibility discussion. Before choosing, write down what the provider handles, what your team handles and what requires both parties.

AreaWhat to establish for a managed serviceWhat to plan for self-hosting
PatchingCovered layers, upgrade timing and required customer actionsMonitoring updates, testing, installation and recovery
BackupsScope, retention, restore access and exclusionsScheduling, storage, protection and restore testing
AvailabilityFailure handling, service commitments and dependenciesMonitoring, recovery design and incident response
PortabilityExport formats, feature dependencies and exit costsRebuild instructions, data exports and migration tests
SupportCovered incidents, response commitments and escalationInternal ownership and any outside support arrangements
CostUsage, capacity, support, recovery and exit chargesInfrastructure, tooling, labour and operational cover

If a responsibility has no named owner, treat it as unresolved before launch. What DevOps means for a business provides useful context for this ownership discussion.

Who handles patches and upgrades?

Ask about each layer separately: the underlying machine, operating system, database or runtime, application dependencies and your own code.

For a managed service, request a written explanation of patch coverage. Can you choose a maintenance window? Must you approve major upgrades? What happens when a version is no longer supported? Which compatibility checks remain your responsibility?

For self-hosting, assign someone to track updates, assess urgency and test changes. Include a recovery procedure for an upgrade that fails or changes behaviour.

In either model, include application compatibility testing in your plan. Establish who can approve an urgent change when waiting for the usual release window is unacceptable.

What would prove that backups work?

Define recovery around the business outcome. How much recent work could you afford to lose? How long could customers wait before the product becomes usable again?

Then test the complete restore process. Recover the data into a separate environment, reconnect the application and check that important workflows still work.

For a managed option, establish:

  • Which data and settings the backup includes.
  • How long copies remain available.
  • Who can request or perform a restore.
  • Whether recovery is possible after losing access to the original account.
  • What restoring costs and which steps need provider assistance.

For self-hosting, make those same decisions and assign responsibility for running them. Keep recovery instructions accessible during an outage, and identify a second person who can use them.

How much availability does the product need?

Describe the consequences of downtime before choosing an architecture. Consider which actions must remain available, which can wait and whether customers need access outside your team's normal working hours.

For a managed service, read the service commitment alongside its exclusions and remedies. Ask what your team must do during an incident and how you will learn whether recovery is progressing.

For self-hosting, explain how you will detect failure, decide what happened and restore service. Include staffing in that explanation. A recovery design that depends on one unavailable person is an unresolved operational risk.

Assess the whole customer journey too. Include the application, database, network, sign-in and outside integrations in the availability discussion. Planning a scalable architecture is a useful next step when deciding how those parts fit together.

What control do you actually require?

Replace “we need control” with a concrete requirement.

You might need a particular extension, custom network access, a specific deployment location or authority over upgrade timing. Check whether each candidate supports the requirement and whether you can verify it before committing.

Separate essential requirements from preferences. Rejecting an otherwise suitable service because of a feature nobody expects to use creates work without a clear product benefit.

Apply the same discipline to self-hosting. Identify who will exercise the extra control, what they will change and how they will maintain it safely. Ownership should have a practical purpose.

How will you leave either option?

Make portability an acceptance test.

For a managed service, export representative data and try using it elsewhere. Include relationships, attachments, permissions and configuration where relevant. Document any provider-specific features that would require application changes.

For self-hosting, rebuild the component from documented instructions in a fresh environment. Check whether another person can recover it without relying on the original operator's memory.

Estimate the work needed to move, the interruption customers would experience and any charges attached to the exit. Keep that estimate proportionate: a tested export and a short list of dependencies may be enough for an early product.

Where does support responsibility stop?

Use a concrete incident to explore the boundary: customers cannot complete an action, but the infrastructure dashboard shows no outage.

Ask who investigates application behaviour, slow queries, connection limits, configuration and infrastructure health. Establish which evidence your team must collect and who coordinates the incident when several suppliers are involved.

For managed services, distinguish the commitment to respond from the commitment to restore service. Confirm the support channel and escalation route available under your proposed plan.

For self-hosting, name the internal incident owner and any outside specialist you would call. Decide how customers receive updates while engineers work on recovery.

How should you compare ongoing costs?

Build both estimates around the same workload and recovery expectations. Include ordinary operation, growth, incidents and leaving the setup.

For managed services, examine the proposed charges for capacity, usage, storage, backups, support and data movement. For self-hosting, include infrastructure, monitoring, backup storage, maintenance time and operational cover.

Illustrative example: suppose a managed option costs 600 currency units per month, while self-hosted infrastructure costs 250. If self-hosting also takes eight engineering hours valued at 60 units each, its comparison total becomes 730 before other costs. The managed option still needs an allowance for your team's configuration, testing and incident work.

These figures are illustrative. The useful result is a cost model that makes labour visible and lets you change the assumptions.

What common mistakes should you avoid?

Calling managed services maintenance-free. List the work your team retains and budget for it.

Choosing self-hosting from the infrastructure bill alone. Include routine maintenance, recovery practice and cover for absence.

Buying complexity for hypothetical growth. Choose for credible needs and record the conditions that would justify reconsidering.

Treating the entire system as one decision. Evaluate components separately. You can choose managed operation for one component and self-host another where control matters.

Leaving recovery until after launch. Require a successful restore before depending on the system for important customer work.

What should you confirm before deciding?

Use this checklist with your technical lead or build partner:

  • Every operational responsibility has a named owner.
  • Required features and controls have been verified.
  • Patch and upgrade procedures are understood.
  • A representative restore has succeeded.
  • Incident cover matches the product's operating hours.
  • Support boundaries and escalation routes are documented.
  • Both cost estimates include your team's ongoing work.
  • An export or rebuild test supports the exit plan.

Choose the option your team can operate consistently. Revisit it when requirements, staffing or workload materially change.

Frequently asked questions

Are managed services always cheaper?

Compare the full operating cost for your workload. Include retained engineering work on the managed side and maintenance and incident cover on the self-hosted side.

Does self-hosting mean running physical servers?

Here, it means your team operates the software component. The underlying infrastructure can still be rented.

Can we switch later?

Plan and test the steps before relying on that possibility. Verify data export, replacement features and the application changes a move would require.

Which option is better for a small team?

Start by testing whether a managed option meets your requirements and removes work you cannot reliably cover. Choose self-hosting where a concrete need justifies the operational commitment.

Whichever you choose, keep the exit cost in view; see how to reduce vendor lock-in.

Ready to build?

Let's turn these ideas into your next product.

Start your project