Every few months, a major cloud or software provider goes down and takes a long list of other businesses with it. Email stops working, logins fail, payment pages hang and support dashboards go blank. The companies affected did nothing wrong in their own code. They simply depended on a vendor that had a bad day.
For startups and SMEs, this is uncomfortable to think about, because modern products are built almost entirely on other people's services. A typical SaaS app might rely on one cloud for hosting, another company for authentication, a third for payments, a fourth for email, a fifth for AI models and a sixth for analytics. Each of those is a potential single point of failure.
The answer is not to build everything yourself, and it is usually not to run two of everything either. The answer is deliberate dependency planning: knowing which vendors matter most, deciding how your product should behave when each one fails, and building just enough resilience to protect the moments that matter to customers. This is different from classic backup planning. If you want the data recovery side of the story, our guide to building a backup and disaster recovery plan with RPO and RTO targets covers it. This article focuses on staying useful while a third party is down.
Three trends make this problem more pressing for small teams.
None of this means vendors are unreliable. Major providers generally run excellent infrastructure. It means that with enough dependencies, something will eventually be unavailable, and your product's behaviour in that moment is a design decision you either make in advance or make in a panic.
Here is an illustrative scenario based on the kind of issue we help clients design around. A clinic booking platform sends one-time passwords by SMS for patient login. One morning, its SMS provider suffers a regional outage. Patients cannot receive codes, so they cannot log in, so they cannot see or reschedule appointments. Front desk staff are flooded with calls, and the clinic owners assume the booking app itself is broken.
The app's servers were perfectly healthy throughout. The failure was a single vendor in a single step of the login flow. A resilient design might have offered an email or WhatsApp fallback for codes, allowed returning patients on trusted devices to stay signed in longer, and shown a clear message explaining that SMS delivery was delayed. None of those require a second cloud. They require someone to have asked, ahead of time, "what happens if this provider stops answering?"
Start with a simple spreadsheet. List every external service your product touches: hosting, DNS, CDN, database provider, authentication, payments, email, SMS, push notifications, maps, AI models, file storage, analytics and support tools. For each, note what it does, which user journeys rely on it, and whether it is called synchronously during a user request.
Not every outage matters equally. An analytics tool going down for an hour is invisible to customers. A payment gateway going down during a sale is not. Score each dependency on two questions: how many users notice, and how much revenue or trust is lost per hour. Focus your effort on the top five or so. Teams often find that only a handful of vendors are truly critical.
For every high-impact dependency, write one paragraph describing how the product should behave without it. Examples:
Many outages hurt only because an external call blocks a page or a checkout. Sending a welcome email, updating a CRM, logging an analytics event or generating a PDF rarely needs to happen before the user sees a response. Push these tasks into background jobs that retry on their own. A simple job queue with automatic retries turns many hard failures into short delays nobody notices.
Every external call should have a timeout measured in seconds, not minutes. Retries should use exponential backoff so you do not hammer a struggling provider. A circuit breaker pattern stops calling a failing service for a short period and immediately serves the degraded mode instead, which keeps your own servers from piling up stuck requests.
Running a backup vendor adds cost and maintenance, so reserve it for dependencies where degraded mode is not acceptable. Transactional email, SMS and AI model access are common candidates because switching is relatively cheap when you wrap the vendor behind your own interface. The same principle applies to AI, as we explain in our guide to building a model-agnostic AI gateway layer.
Subscribe to every critical vendor's status page, route those alerts into the same channel as your own monitoring, and add synthetic checks that exercise key journeys end to end. That way you learn about a vendor outage from your dashboard, not from an angry customer.
Write template messages in advance for each critical scenario, and keep a status page that is hosted independently of your main infrastructure. A short, honest message such as "Card payments are delayed due to a provider issue. Your order is saved and you will receive a payment link shortly" prevents a flood of support tickets.
Run a short game day: disable a vendor in staging using feature flags or a blocked network route, and watch what breaks. Document the results and fix the surprises. After each real incident, run a blameless review and update the plan.
Resilience for a small team is rarely about duplicating infrastructure. It is about making sure no single vendor can stop a customer from finishing the one thing they came to do.
For an early-stage product, the first four steps are often enough: map dependencies, rank them, define degraded modes and remove avoidable calls from the critical path. As revenue grows and customers depend on you for daily operations, add secondary providers and regular rehearsals. When our team plans architecture for new SaaS products, we build these patterns in from the start, because adding them later usually means touching every integration twice.
You cannot prevent your cloud, payment, messaging or AI vendors from having outages. You can decide, calmly and in advance, how your product behaves when they do. Map your dependencies, focus on the few that customers would notice, design graceful degraded modes, keep external calls out of the critical path, and communicate honestly when something goes wrong.
Do this well and the next big provider outage becomes a minor inconvenience for your users instead of a crisis for your business. In a world built on shared infrastructure, that quiet reliability is one of the most underrated competitive advantages a small company can have.