How would you design a real-time collaborative document editor like Google Docs (OT vs CRDT)

package com.bank.collab.model;

public class TextOperation {
    enum Type { INSERT, DELETE }
    private Type type;
    private int position;
    private String character;
    private String userId;

    public TextOperation(Type type, int position, String character, String userId) {
        this.type = type;
        this.position = position;
        this.character = character;
        this.userId = userId;
    }

    public Type getType() { return type; }
    public int getPosition() { return position; }
    public void setPosition(int p) { this.position = p; }
}

package com.bank.collab.ot;

import com.bank.collab.model.TextOperation;
import com.bank.collab.model.TextOperation.Type;

public class OperationalTransformer {

    public static TextOperation transform(TextOperation incoming, TextOperation applied) {
        TextOperation transformed = new TextOperation(
            incoming.getType(), incoming.getPosition(),
            incoming.getCharacter(), incoming.getUserId());

        if (applied.getType() == Type.INSERT) {
            if (incoming.getPosition() >= applied.getPosition()) {
                transformed.setPosition(incoming.getPosition() + 1);
            }
        } else if (applied.getType() == Type.DELETE) {
            if (incoming.getPosition() > applied.getPosition()) {
                transformed.setPosition(incoming.getPosition() - 1);
            }
        }
        return transformed;
    }

    public static void main(String[] args) {
        // Rajesh inserts 'A' at position 0
        TextOperation rajeshOp = new TextOperation(Type.INSERT, 0, "A", "Rajesh");
        // Priya deletes at position 5 (concurrent)
        TextOperation priyaOp = new TextOperation(Type.DELETE, 5, "", "Priya");

        // After applying Rajesh's insert, Priya's position must shift right by 1
        TextOperation transformedPriya = transform(priyaOp, rajeshOp);
        System.out.println("Priya's original position: " + priyaOp.getPosition());
        System.out.println("Priya's transformed position: " + transformedPriya.getPosition());
    }
}

Priya's original position: 5
Priya's transformed position: 6

package com.bank.collab.crdt;

import java.util.TreeMap;
import java.util.UUID;

public class SimpleCrdtDocument {

    private final TreeMap<String, Character> chars = new TreeMap<>();

    public void insert(String positionId, char c) {
        chars.put(positionId, c);
    }

    public void delete(String positionId) {
        chars.remove(positionId); // tombstone in real impl
    }

    public String render() {
        StringBuilder sb = new StringBuilder();
        chars.values().forEach(sb::append);
        return sb.toString();
    }

    public static void main(String[] args) {
        SimpleCrdtDocument doc = new SimpleCrdtDocument();
        // Rajesh inserts 'H' with ID "a1"
        doc.insert("a1", 'H');
        // Priya inserts 'i' with ID "a2" (after a1)
        doc.insert("a2", 'i');
        // Order of inserts does not matter: IDs determine position
        System.out.println(doc.render()); // "Hi"
    }
}

Hi

package com.bank.collab.persistence;

import java.util.List;

public class OpLogStore {

    public void appendOp(String docId, TextOperation op) {
        // Append to ordered log
    }

    public String loadDocument(String docId) {
        // Load latest snapshot
        String snapshot = loadSnapshot(docId);
        // Replay ops since snapshot
        List<TextOperation> ops = loadOpsSinceSnapshot(docId);
        return applyOps(snapshot, ops);
    }

    private String loadSnapshot(String d) { return ""; }
    private List<TextOperation> loadOpsSinceSnapshot(String d) { return List.of(); }
    private String applyOps(String s, List<TextOperation> ops) { return s; }
}

package com.bank.collab.sync;

public class CollabSyncFlow {
    // 1. Rajesh types a character -> applied locally immediately (optimistic)
    // 2. Operation sent to server via WebSocket
    // 3. Server applies OT/CRDT merge, assigns global order
    // 4. Merged result broadcast to Priya's WebSocket
    // 5. Priya's client applies the operation
    // Result: both see the same document
}

package com.bank.collab.offline;

import java.util.ArrayList;
import java.util.List;

public class OfflineBuffer {

    private final List<TextOperation> bufferedOps = new ArrayList<>();
    private boolean connected = true;

    public void onEdit(TextOperation op) {
        if (!connected) {
            bufferedOps.add(op);
        }
    }

    public List<TextOperation> onReconnect() {
        List<TextOperation> toReplay = new ArrayList<>(bufferedOps);
        bufferedOps.clear();
        connected = true;
        return toReplay;
        // OT: transform against missed ops
        // CRDT: simply merge (ops commute)
    }
}