5G Core Service-Based Architecture is formally specified in 3GPP TS 23.501 (architecture) and TS 23.502 (procedures), using a concrete HTTP/2 and OpenAPI-based framework called the Service-Based Interface (SBI) — a genuinely different communication model from every dedicated point-to-point interface LTE’s EPC relied on.
Diagram for Module 9
Diagram: 5G Core Service-Based Architecture — network functions communicating over a shared service bus.
How LTE’s EPC was wired together
LTE’s core network connects its network functions through dedicated, point-to-point interfaces, each specified individually in 3GPP TS 23.401: S1-MME between eNB and MME, S11 between MME and S-GW, S5 between S-GW and P-GW, S6a between MME and HSS (using Diameter). Each interface is purpose-built for a specific pair of functions. This model doesn’t naturally support flexible, many-to-many communication — adding a new function or letting an existing one interact differently meant defining a new dedicated interface each time.
5G Core’s answer: named services over SBI
5G Core largely replaces this with Service-Based Architecture: network functions expose standardized services with formal names, each prefixed with N and the function name — Namf (AMF services), Nsmf (SMF services), Nudm (UDM services), Npcf (PCF services), Nnrf (NRF services) — called by other functions over the shared SBI, using RESTful HTTP/2 methods (GET, POST, PUT, PATCH, DELETE) defined precisely in each function’s OpenAPI specification within TS 23.502’s annexes.
Producer, consumer, and the NRF registry
SBA formalizes network functions into service producers and service consumers, with many functions acting as both. The NRF (Network Repository Function) — its own service, Nnrf, covered in more depth in Module 10 — acts as the registry: producer functions register available services via Nnrf_NFManagement, and consumers discover them via Nnrf_NFDiscovery, rather than needing hard-coded knowledge of specific network function instances the way EPC’s point-to-point interfaces implicitly assumed.
Not everything is SBI — the reference points that remain
It’s worth being precise here, since this is a nuance many explainers gloss over: not every 5G Core interaction runs over SBI. Certain interfaces remain defined as traditional reference points rather than services — notably N1 (UE to AMF, NAS signaling), N2 (AMF to RAN), N3 (RAN to UPF, user-plane), and N4 (SMF to UPF, using the PFCP protocol, covered in Module 11). These carry either NAS/RRC-layer signaling or user-plane traffic that doesn’t map naturally onto a RESTful service model, so 3GPP kept them as more traditional point-to-point reference points even within an overall SBA design.
Why this matters beyond architectural elegance
This shift produces genuinely practical benefits tracing back to Module 1’s design brief: easier extensibility, since a new function registers with the NRF and starts consuming/producing services without every other function needing a bespoke new interface; better support for network slicing (Module 12), because service-oriented interaction makes it more practical to instantiate different function combinations per slice; and alignment with cloud-native deployment, letting operators run 5G Core functions using the same container orchestration and DevOps practices increasingly standard across their broader IT estate.
The tradeoff worth being honest about
SBA introduces genuinely new complexity around service discovery, OpenAPI versioning across releases, and securing a shared HTTP/2 bus that a smaller set of purpose-built interfaces didn’t have to worry about in the same way. This is 5G repeatedly accepting more architectural and operational complexity in exchange for the flexibility IMT-2020’s broader requirement set demands.
What comes next
SBA and the named service framework (Namf, Nsmf, Nnrf, and the rest) is the architectural skeleton; the next module gets specific about which network functions actually exist within it and what each one does day to day.
Next in this series: Module 10 — The Key 5G Core Network Functions: AMF, SMF, and UPF, and How They Divide Labor.