What is Peer-to-Peer architecture, and when is it the right fit?

package com.bank.p2p;

/**
 * A simplified peer that can both serve and request data.
 * In a real P2P network, this communicates over sockets.
 */
public class BankPeer {

    private final String peerId;
    private final java.util.Map<String, String> localLedger = new java.util.HashMap<>();

    public BankPeer(String peerId) {
        this.peerId = peerId;
    }

    // Serve: respond to another peer's request
    public String serve(String key) {
        return localLedger.getOrDefault(key, "NOT_FOUND");
    }

    // Request: ask another peer for data
    public String requestFrom(BankPeer other, String key) {
        return other.serve(key);
    }

    public void store(String key, String value) {
        localLedger.put(key, value);
    }
}

Expected: each peer can both store/serve data and request data from others.
No central server required.

package com.bank.p2p;

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

public class PeerDiscovery {

    private final List<String> knownPeers = new ArrayList<>();

    public PeerDiscovery(List<String> bootstrapNodes) {
        knownPeers.addAll(bootstrapNodes);
    }

    public void discoverMore() {
        // Ask each known peer for its neighbor list
        System.out.println("Querying " + knownPeers.size() + " bootstrap nodes for more peers...");
        // In production: connect to each, exchange peer lists
        knownPeers.add("peer-4.nbi.internal");
        knownPeers.add("peer-5.nbi.internal");
        System.out.println("Known peers now: " + knownPeers.size());
    }

    public static void main(String[] args) {
        PeerDiscovery discovery = new PeerDiscovery(
            List.of("peer-1.nbi.internal", "peer-2.nbi.internal", "peer-3.nbi.internal")
        );
        discovery.discoverMore();
    }
}

Querying 3 bootstrap nodes for more peers...
Known peers now: 5

package com.bank.p2p;

import java.util.TreeMap;

public class SimpleDHT {

    // Simulates a DHT ring with node positions
    private final TreeMap<Integer, String> ring = new TreeMap<>();

    public void addNode(String nodeId, int hashPosition) {
        ring.put(hashPosition, nodeId);
    }

    public String findResponsible(String key) {
        int keyHash = Math.abs(key.hashCode() % 1000);
        var entry = ring.ceilingEntry(keyHash);
        if (entry == null) entry = ring.firstEntry(); // wrap around
        return entry.getValue();
    }

    public static void main(String[] args) {
        SimpleDHT dht = new SimpleDHT();
        dht.addNode("nbi-branch-mumbai", 100);
        dht.addNode("nbi-branch-delhi", 400);
        dht.addNode("nbi-branch-chennai", 700);

        System.out.println("Account SAV2001 handled by: " + dht.findResponsible("SAV2001"));
        System.out.println("Account CUR3005 handled by: " + dht.findResponsible("CUR3005"));
    }
}

Account SAV2001 handled by: nbi-branch-delhi
Account CUR3005 handled by: nbi-branch-chennai

package com.bank.p2p;

// Client-Server: one authority, simple
public class ClientServerModel {
    // Server is the single source of truth
    // Client sends request, server processes, returns response
    // Simple, reliable, easy to reason about
}

// Peer-to-Peer: no authority, complex
public class PeerToPeerModel {
    // Every node holds a copy, agrees by consensus
    // No single point of failure, but consistency is hard
    // Security is harder (Sybil attacks, malicious peers)
}

package com.bank.p2p;

// Sybil attack: one malicious actor creates many fake peers
public class SybilAttackDemo {
    public static void main(String[] args) {
        int legitimatePeers = 10;
        int fakePeersFromOneActor = 50;
        int totalPeers = legitimatePeers + fakePeersFromOneActor;

        double attackerInfluence = (double) fakePeersFromOneActor / totalPeers * 100;
        System.out.println("Attacker controls " + String.format("%.1f", attackerInfluence)
                + "% of the network with fake peers");
        System.out.println("Mitigation: proof-of-work, proof-of-stake, or identity verification");
    }
}

Attacker controls 83.3% of the network with fake peers
Mitigation: proof-of-work, proof-of-stake, or identity verification

package com.bank.p2p;

import java.math.BigDecimal;
import java.util.List;

public class ConsortiumSettlement {

    record SettlementEntry(String fromBank, String toBank, BigDecimal amount) {}

    static boolean majorityApproves(List<Boolean> votes) {
        long approvals = votes.stream().filter(v -> v).count();
        return approvals > votes.size() / 2;
    }

    public static void main(String[] args) {
        SettlementEntry entry = new SettlementEntry(
            "National Bank of India", "HDFC", new BigDecimal("5000000.00"));

        List<Boolean> peerVotes = List.of(true, true, true, false, true);
        boolean committed = majorityApproves(peerVotes);

        System.out.println("Settlement: " + entry);
        System.out.println("Majority approved: " + committed);
    }
}

Settlement: SettlementEntry[fromBank=National Bank of India, toBank=HDFC, amount=5000000.00]
Majority approved: true