The dead Internet is not a theory anymore

As SaaS developers, we've long been aware of the importance of building robust systems that can withstand unexpected outages and disruptions. However, a recent trend suggests that the internet may be on the cusp of a profound shift, with the potential to fragment into smaller, isolated networks. In this article, we'll explore the implications of this shift and provide actionable strategies for SaaS developers to prepare for the worst-case scenario.

What is the "Dead Internet"?

The concept of a "dead internet" refers to a scenario in which the global internet infrastructure becomes severely fragmented, with various networks and systems becoming isolated from one another. This could be due to a combination of factors, including widespread cyber attacks, nation-state sponsored hacking, or even a catastrophic event that disables critical infrastructure.

In such a scenario, SaaS applications that rely on a single, central internet connection may find themselves unable to function or access critical resources. This could lead to a breakdown in service, resulting in lost revenue, damaged reputation, and even legal liability.

Preparing for the Worst-Case Scenario

So, how can SaaS developers prepare for the worst-case scenario? Here are some actionable strategies to consider:

1. Implement a Peer-to-Peer (P2P) Architecture

A P2P architecture allows nodes to communicate directly with one another, eliminating the need for a central hub or internet connection. This can be achieved using technologies like WebRTC (Web Real-Time Communication) or IPFS (InterPlanetary File System).

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', (ws) => {
    console.log('Client connected');

    ws.on('message', (message) => {
        console.log(`Received message -> ${message}`);
        ws.send(`Server received your message: ${message}`);
    });

    ws.on('close', () => {
        console.log('Client disconnected');
    });
});

2. Utilize a Local Database

By storing data locally on each node, SaaS applications can reduce their reliance on centralized databases and minimize the impact of internet disruptions. This can be achieved using technologies like SQLite or LevelDB.

const sqlite3 = require('sqlite3').verbose();
const db = new sqlite3.Database('example.db');

db.serialize(() => {
    db.run(`CREATE TABLE users (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        email TEXT NOT NULL
    )`);

    db.run(`INSERT INTO users (name, email) VALUES (?, ?)`, 'John Doe', 'john@example.com');
});

3. Employ a Decentralized Authentication System

A decentralized authentication system allows users to authenticate directly with the SaaS application, eliminating the need for a central authentication server. This can be achieved using technologies like OAuth or OpenID Connect.

const express = require('express');
const app = express();

app.get('/login', (req, res) => {
    const authorizationUrl = 'https://example.com/oauth/authorize?response_type=code&client_id=your_client_id';
    res.redirect(authorizationUrl);
});

4. Implement a Robust Edge Network

A robust edge network involves deploying a network of edge servers that cache and serve content to users, reducing the need for data to be transmitted over long distances. This can be achieved using technologies like Cloudflare or NGINX.

const express = require('express');
const app = express();

app.use(express.static('public'));

app.listen(80, () => {
    console.log('Server listening on port 80');
});

5. Develop a Disconnected User Experience

A disconnected user experience involves designing the SaaS application to function optimally even when disconnected from the internet. This can involve using local storage, caching data, and implementing a queue-based system for processing tasks.

const localStorage = window.localStorage;

localStorage.setItem('username', 'John Doe');

const storedUsername = localStorage.getItem('username');
console.log(storedUsername); // "John Doe"

Conclusion

The potential for the internet to fragment into smaller, isolated networks poses a significant risk to SaaS applications that rely on a single, central internet connection. However, by implementing a P2P architecture, utilizing a local database, employing a decentralized authentication system, implementing a robust edge network, and developing a disconnected user experience, SaaS developers can prepare for the worst-case scenario and ensure business continuity even in the face of catastrophic disruptions.

If you're using DiggaByte's Next.js + Prisma stack, for example, you can take advantage of Prisma's built-in support for local databases and decentralized authentication systems to build a robust and resilient SaaS application.

By taking proactive steps to prepare for the worst-case scenario, SaaS developers can ensure that their applications remain available, secure, and functional even in the most challenging circumstances. It's time to rethink our approach to building SaaS applications and prioritize resilience and business continuity above all else.