FL System Architecture: The Complete Client–Server Topology Guide

The Blueprint Before the Bricks

Before writing a single line of FL code, every practitioner must understand the system topology — how components connect, communicate, and co-ordinate. Getting this wrong means models that diverge, clients that stall, and systems that collapse the moment a single node drops off the network.

The Core Client–Server Topology

The canonical FL topology is a star network: one central server (or a small cluster) at the hub, and N clients at the spokes. This is not the only topology (we will cover hierarchical and P2P variants), but it is where every FL practitioner starts.

📋 What Each Node Does

The Communication Protocol Stack

Data flowing between server and clients doesn't travel as raw Python objects. A full protocol stack handles serialisation, compression, encryption, and transport. Understanding each layer prevents the most common production failures.

Synchronous vs. Asynchronous Operation

One of the most consequential architectural decisions is whether the server waits for all selected clients before aggregating, or whether it aggregates whenever updates arrive. This is the sync vs. async trade-off.

The Full Round Lifecycle — Step by Step

A single FL communication round is more complex than it first appears. Here is every state transition from round start to round end, with the exact data flowing at each step.

Beyond Star: Three Topology Variants

The standard client–server star works well for up to ~10,000 clients. Above that, or in settings with geographic constraints, three extended topologies are used in production.

Client Selection Strategies

Which clients train in each round is one of the most impactful decisions in FL system design. Random selection is the baseline — but it ignores data quality, connectivity, and model bias.

Implementing FL Architecture with Flower

Flower (flwr) is the most widely used FL framework, designed to be framework-agnostic (works with PyTorch, TensorFlow, JAX, scikit-learn). It implements the full client–server topology we've described, using gRPC for communication.

💻 Complete Flower Server Implementation

# server.py — FL Aggregation Server with Custom FedAvg Strategy
import flwr as fl
from flwr.common import Metrics
from typing import List, Tuple, Optional, Dict
import numpy as np

# ── Custom weighted FedAvg strategy ──────────────────────
class WeightedFedAvg(fl.server.strategy.FedAvg):
    """FedAvg + server-side evaluation logging."""

    def aggregate_fit(
        self,
        server_round: int,
        results: List,
        failures: List,
    ) -> Tuple[Optional[fl.common.Parameters], Dict]:

        # Log participation stats each round
        total     = len(results) + len(failures)
        success   = len(results)
        fail_rate = len(failures) / total if total > 0 else 0
        print(f"[Round {server_round}] Clients: {success}/{total} "
              f"| Failure rate: {fail_rate:.1%}")

        # Delegate aggregation to parent FedAvg
        aggregated_params, metrics = super().aggregate_fit(
            server_round, results, failures
        )
        return aggregated_params, metrics

    def aggregate_evaluate(
        self,
        server_round: int,
        results: List,
        failures: List,
    ) -> Tuple[Optional[float], Dict]:
        # Weighted average of client-reported losses
        if not results:
            return None, {}

        total_samples   = sum([num for num, _ in results])
        weighted_losses = sum([num * loss
                           for num, loss in results]) / total_samples
        print(f"[Round {server_round}] Global loss: {weighted_losses:.4f}")
        return weighted_losses, {}

# ── Server configuration ──────────────────────────────────
strategy = WeightedFedAvg(
    fraction_fit=0.1,           # 10% of clients per round
    fraction_evaluate=0.05,     # 5% of clients for eval
    min_fit_clients=10,         # minimum to start a round
    min_evaluate_clients=5,     # minimum for evaluation
    min_available_clients=50,   # wait until 50 clients connect
)

# ── Start the server ──────────────────────────────────────
if __name__ == "__main__":
    fl.server.start_server(
        server_address="0.0.0.0:8080",   # gRPC endpoint
        config=fl.server.ServerConfig(num_rounds=20),
        strategy=strategy,
    )

💻 Complete Flower Client Implementation

# client.py — FL Client Node (PyTorch backend)
import flwr as fl
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from collections import OrderedDict
from typing import List, Dict, Tuple
import numpy as np

# ── Model definition ──────────────────────────────────────
class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(1, 32, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1),
            nn.ReLU(),
            nn.AdaptiveAvgPool2d((4, 4)),
        )
        self.fc = nn.Linear(64 * 4 * 4, 10)

    def forward(self, x):
        return self.fc(self.conv(x).flatten(1))

# ── Flower client class ───────────────────────────────────
class FLClient(fl.client.NumPyClient):
    def __init__(self, model, trainloader, valloader, client_id):
        self.model       = model
        self.trainloader = trainloader
        self.valloader   = valloader
        self.client_id   = client_id
        self.device      = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.model.to(self.device)

    def get_parameters(self, config) -> List[np.ndarray]:
        # Extract model weights as NumPy arrays → Flower serialises to protobuf
        return [val.cpu().numpy() for _, val
                in self.model.state_dict().items()]

    def set_parameters(self, parameters: List[np.ndarray]):
        # Load server weights into local model
        params_dict  = zip(self.model.state_dict().keys(), parameters)
        state_dict   = OrderedDict(
            {k: torch.tensor(v) for k, v in params_dict}
        )
        self.model.load_state_dict(state_dict, strict=True)

    def fit(self, parameters, config) -> Tuple[List, int, Dict]:
        # Step 1: load global weights from server
        self.set_parameters(parameters)

        # Step 2: read hyperparams from server config
        lr         = config.get("learning_rate", 0.01)
        epochs     = config.get("local_epochs",  3)
        batch_size = config.get("batch_size",    32)

        # Step 3: local training
        optimizer = torch.optim.SGD(self.model.parameters(),
                                     lr=lr, momentum=0.9)
        criterion = nn.CrossEntropyLoss()
        self.model.train()

        for _ in range(epochs):
            for images, labels in self.trainloader:
                images, labels = images.to(self.device), labels.to(self.device)
                optimizer.zero_grad()
                criterion(self.model(images), labels).backward()
                optimizer.step()

        # Step 4: return updated weights + dataset size (for weighted FedAvg)
        return self.get_parameters(config={}), len(self.trainloader.dataset), {}

    def evaluate(self, parameters, config) -> Tuple[float, int, Dict]:
        self.set_parameters(parameters)
        criterion = nn.CrossEntropyLoss()
        self.model.eval()
        loss, correct = 0.0, 0

        with torch.no_grad():
            for images, labels in self.valloader:
                images, labels = images.to(self.device), labels.to(self.device)
                outputs = self.model(images)
                loss    += criterion(outputs, labels).item()
                correct += (outputs.argmax(1) == labels).sum().item()

        n        = len(self.valloader.dataset)
        accuracy = correct / n
        return loss / len(self.valloader), n, {"accuracy": accuracy}

# ── Launch the client ─────────────────────────────────────
if __name__ == "__main__":
    import sys
    client_id = int(sys.argv[1]) if len(sys.argv) > 1 else 0

    # Each client loads ONLY its own local data partition
    trainloader, valloader = load_local_partition(client_id)
    model  = Net()
    client = FLClient(model, trainloader, valloader, client_id)

    fl.client.start_client(
        server_address="server-host:8080",   # gRPC server address
        client=client.to_client(),
    )

Architecture Decision Guide

Choosing the right topology and operating mode depends on your specific constraints. Use this table to make the decision systematically.

Architecture Golden Rules