Is Software Just Less Reliable Now? The Truth About Platform Stability

Introduction

Every week something breaks. Your AI IDE, GitHub Actions, your cloud provider, a third-party service.

Software isn't getting worse. Systems have just never been this hyper-connected.

Old monoliths: One thing running locally, mostly independent. Modern stacks: 50 dependencies (AI IDEs, auth providers, payment processors, analytics, managed databases).

The Math of Dependencies

1 dependency = 99.9% uptime = 43 minutes down/month 10 dependencies = 99.9%^10 = 99% uptime = 7.2 hours down/month 50 dependencies = 99.9%^50 = 95% uptime = 36 hours down/month

You're down 1.5 days per month. Not through failure of engineering. Through math.

How to Build Defensively

Graceful Degradation: If analytics fails, users still get responses.

Smart Retries: Exponential backoff with jitter (don't hammer failing services).

Circuit Breakers: If a service fails 5 times, stop calling it for 60 seconds.

Timeouts Everywhere: Don't let requests hang forever (5 second timeout standard).

Bulkheads / Isolation: Different services get different connection pools.

The Pattern

Classify dependencies:

• Critical: Auth, payments, core data
• Non-critical: Analytics, tracking, recommendations

Critical paths fail fast. Non-critical fail silently.

Related Guides

For deployment best practices, see The Only Pre-Deployment Checklist You Need. For understanding when to add dependencies, see Microservices vs. Monoliths.

Also review System Evolution: How to Scale Your Infrastructure to understand how to monitor for these failure modes.

Key Takeaways

1. Modern systems are inherently more fragile - More dependencies = more risk
2. Cascading failures are inevitable - One service failing cascades through the stack
3. Build for defensiveness - Graceful degradation, retries, circuit breakers
4. Classify dependencies - Critical vs non-critical, fail differently
5. Timeout everything - Don't let requests hang forever

Your goal isn't to prevent failures (you can't). Your goal is to gracefully handle them when they happen.

For more on fault tolerance, see Release It!: Design and Deploy Production-Ready Software by Michael Nygard.

---

Remember: The more dependencies you have, the more defensive your code needs to be. Every external API you call is a potential source of failure. Plan for it.