Building a Chat App with Zero Databases

The Problem with Traditional Chat Apps

Every messaging app today follows the same pattern: users → servers → databases. This architecture creates a fundamental privacy problem. Even with end-to-end encryption, these apps still collect metadata - who you talk to, when, for how long, and from where. This metadata can be more revealing than the messages themselves.

Our Radical Solution: No Servers, No Databases

Vant Chat eliminates the middleman entirely. Instead of routing messages through central servers, we use a peer-to-peer architecture combined with temporary relay nodes that don't store any data. Here's how it works:

Device A

↔

Temporary Relay (No Storage)

↔

Device B

Key Architectural Principles

Device-to-Device Encryption: Messages are encrypted on the sender's device and can only be decrypted on the recipient's device.
Temporary Relay Nodes: Relay nodes only forward encrypted packets - they cannot read them and don't store them.
Local Storage Only: All contacts, messages, and app data are stored exclusively on user devices.
No User Accounts: Without accounts, there's no user data to collect or profile.

Technical Implementation

1. Peer Discovery Without Central Servers

Traditional apps use centralized user directories. We use distributed hash tables (DHT) combined with cryptographic identifiers:

Device Identifier Generation

// Generate unique device ID without personal info
const deviceId = crypto.subtle.digest('SHA-256', 
    deviceFingerprint + randomSalt
);

// Public key becomes the "address"
const deviceAddress = await crypto.subtle.exportKey('spki', publicKey);
                

2. Message Routing Architecture

Messages travel through a network of volunteer relay nodes. Each node only sees encrypted packets and forwards them based on routing headers:

Relay Node Processing

// Relay node cannot decrypt, only routes
function routeMessage(encryptedPacket) {
    const header = decryptHeader(encryptedPacket.routingHeader, nodeKey);
    const nextHop = header.nextRelay;
    
    // Forward without storing
    forwardToNode(encryptedPacket, nextHop);
    
    // Immediately delete from memory
    encryptedPacket = null;
}
                

3. Offline Message Handling

When a recipient is offline, we use a clever approach with ephemeral storage:

Messages are encrypted with the recipient's public key
Stored temporarily in memory on random relay nodes
Automatically deleted after 24 hours or when delivered
No persistent storage or databases involved

Ephemeral Storage

const messageStore = new Map(); // In-memory only

function storeOfflineMessage(recipientId, encryptedMessage) {
    const expiry = Date.now() + (24 * 60 * 60 * 1000); // 24 hours
    
    messageStore.set(recipientId, {
        message: encryptedMessage,
        expires: expiry
    });
    
    // Auto-cleanup
    setTimeout(() => {
        messageStore.delete(recipientId);
    }, 24 * 60 * 60 * 1000);
}
                

Security Benefits

1. Government Resistance

When governments request user data, our response is simple: "We don't have any." This isn't a legal argument - it's a technical reality. We cannot provide data that doesn't exist.

2. No Data Breaches

Data breaches are impossible when there's no data to breach. Even if our relay nodes were compromised, attackers would only find encrypted packets they cannot decrypt.

3. Metadata Protection

Traditional apps know your entire social graph. Vant Chat only knows what your device knows - your contacts, stored locally and encrypted.

Performance Optimizations

1. Smart Relay Selection

We use machine learning to select optimal relay nodes based on:

Network latency
Node reliability
Geographic proximity
Current load

2. Message Batching

Multiple small messages are batched together to reduce overhead and improve delivery speed.

Message Batching

class MessageBatcher {
    constructor(batchSize = 10, flushInterval = 100) {
        this.messages = [];
        this.batchSize = batchSize;
        this.flushInterval = flushInterval;
    }
    
    addMessage(message) {
        this.messages.push(message);
        
        if (this.messages.length >= this.batchSize) {
            this.flush();
        }
    }
    
    flush() {
        if (this.messages.length > 0) {
            const batch = this.messages.splice(0);
            this.sendBatch(batch);
        }
    }
}
                

The Future of Private Communication

This zero-server architecture represents a paradigm shift in digital communication. By making privacy technically guaranteed rather than policy-based, we're creating a new standard for secure messaging.

As governments worldwide increase surveillance demands and tech companies continue to exploit user data, architectures like Vant Chat's become not just preferable, but necessary for preserving fundamental human rights to privacy and free expression.

Join the Privacy Revolution

Experience messaging the way it should be - private, secure, and free from surveillance.

Download Vant Chat Now

Technical Resources

For developers interested in learning more about our architecture: