EPC vs 5GC

The EPC was drawn as a network diagram of boxes. The MME is the control brain. The S-GW and P-GW move user packets. The HSS is the subscriber database. The PCRF sets policy. Between them sit named reference points — S6a, S11, S5/S8, Gx — each with its own protocol (Diameter for signalling, GTP for tunnelling). To add capacity you deploy another MME or another gateway and re-plumb the connections. It works, and it has carried 4G for over a decade, but it's rigid: functions are coupled to hardware, and interfaces are bilateral.

5GC takes the opposite approach. Instead of boxes with private links, the core is a collection of network functions that publish services on a common bus. Any NF that needs something — say the AMF needs to authenticate a UE — calls the service it wants (here, the AUSF) rather than talking down a dedicated wire. The functions are software, so you scale the AMF independently of the UPF, run several instances behind a load balancer, and update one function without touching the rest. That's the meaning of service-based architecture.

Most EPC functions have a 5GC counterpart, but the lines aren't always one-to-one. The big one is that the MME splits in two:

• MME → AMF + SMF. The MME's mobility and connection management (NAS, registration, paging) goes to the AMF; its session and bearer logic (now PDU sessions, UPF selection, IP allocation) goes to the SMF.
• S-GW + P-GW (user plane) → UPF. The two 4G gateways collapse into a single UPF for packet forwarding and mobility anchoring. Their control-plane duties move to the SMF.
• HSS → UDM/UDR + AUSF. Subscriber data management lands in UDM (backed by the UDR data store); the authentication-server role becomes the AUSF.
• PCRF → PCF. Policy and charging control becomes the PCF, now an SBA service consumed by SMF and AMF.

5GC also adds functions with no EPC equivalent — the NRF for discovery, the NSSF for slice selection, the NEF for exposing APIs to outside applications. So it isn't a straight rename; it's a re-decomposition.

The EPC's protocols were each purpose-built — Diameter for AAA and policy, GTP for tunnelling. They're efficient at those jobs but awkward to extend; adding a capability often meant a new interface and a new spec.

5GC standardised on HTTP/2 as the transport for the service-based interface (SBI), with JSON payloads and REST-style APIs. The practical wins:

• One transport, many services. Adding a function means publishing new endpoints, not inventing a new protocol stack.
• Discovery, not wiring. A new NF registers its profile with the NRF; consumers query the NRF to find it. No flag-day reconfiguration of peers.
• Cloud-native fit. HTTP/2 is what web-scale tooling — service meshes, API gateways, load balancers — already speaks, so the core slots into the same DevOps pipeline as everything else.

The user plane is the exception: N3 (gNB to UPF) and N9 (UPF to UPF) still use GTP-U for high-rate packet tunnelling. SBA governs the control plane, where flexibility matters more than raw forwarding speed.