Part 1: The 4G Evolved Packet Core (EPC) Architecture
The EPC was a significant leap forward from 3G, designed to create an all-IP network optimized for high-speed mobile data. Its architecture is characterized by a "point-to-point" design, where specific network nodes are connected via standardized interfaces and protocols.
Core Philosophy of 4G EPC
- All-IP Network Eliminated the old circuit-switched domains for voice, handling everything as packet-switched data. Voice is delivered as data packets via VoLTE (Voice over LTE).
- Node-Based Architecture The network is composed of distinct, often monolithic, hardware-based nodes (like MME, SGW, PGW). Each node has a specific, bundled set of functions.
- Optimized for Mobile Broadband The primary goal was to deliver fast, reliable internet to smartphones. Other use cases like massive IoT or ultra-low latency were not primary design considerations.
Key Network Elements (Nodes) of the 4G EPC
- Authentication & Security: Initiates authentication with HSS, manages security keys
- Mobility Management: Tracks UE location and manages handovers between eNodeBs
- Session Management: Manages signaling for bearer creation, maintenance, and teardown
- UE Reachability: Handles paging to find UE for incoming data
- Local Mobility Anchor: Anchor point for UE movement between eNodeBs
- Packet Routing: Forwards uplink/downlink data between eNodeB and PGW
- Buffering: Buffers downlink packets during handovers
- Charging: Collects per-user charging data
- IP Address Allocation: Assigns IP address to UE for session duration
- Policy Enforcement (PCEF): Enforces QoS and rate limits from PCRF
- Packet Filtering: Deep packet inspection based on rules
- Interconnection: Exit/entry point for all user traffic to external networks
- Subscriber Profile: Stores user identity (IMSI), services, QoS profiles
- Authentication Center (AuC): Contains auth keys and generates security vectors
- Location Information: Stores current MME registration for user lookup
- Policy Decisions: Defines QoS based on subscription and network conditions
- Flow-Based Charging: Rules for charging specific data flows
- Gating Control: Can block or allow certain traffic types
Part 2: The 5G Core (5GC) Architecture
The 5GC is a complete redesign, built from the ground up on modern IT principles to be a flexible, scalable, and programmable platform for a vast array of services. This is not just an evolution—it's a revolution.
Core Philosophy of 5G Core
- Service-Based Architecture (SBA) The monolithic nodes of 4G are deconstructed into modular, self-contained Network Functions (NFs). These NFs expose their functionality as "services" to other NFs via well-defined APIs (Application Programming Interfaces), typically using RESTful APIs over HTTP/2. This is like a microservices architecture for the telecom world.
- Cloud-Native Design NFs are designed as software applications that can run in containers (like Docker) on any cloud infrastructure (private, public, hybrid). This allows for independent scaling, automated management (with orchestrators like Kubernetes), and resilience.
- Control and User Plane Separation (CUPS) This principle is fully realized in 5G. Signaling traffic (Control Plane) is completely separated from user data traffic (User Plane). This allows the User Plane Function (UPF) to be deployed closer to the network edge for low-latency applications (Multi-access Edge Computing - MEC).
All NFs communicate via RESTful APIs over the Service Bus
💡 Key Insight: In 5G, network functions don't have fixed point-to-point connections. Instead, they discover each other via the NRF and communicate through standardized service APIs—just like modern web applications!
Key Network Functions (NFs) of the 5G Core
- 4G Analogy: Access & mobility parts of MME
- Registration: UE registration and connection management
- Reachability: UE reachability and notification handling
- Mobility: Handover signaling and mobility management
- 4G Analogy: Session part of MME + SGW-C + PGW-C
- PDU Session: Establishment, modification, and release
- UPF Control: Selects and controls the User Plane Function
- IP Allocation: Assigns IP addresses to UE sessions
- Policy Interface: Interfaces with PCF for policy enforcement
- 4G Analogy: User plane of SGW + PGW (SGW-U + PGW-U)
- Packet Routing: Routes and forwards user data packets
- QoS Handling: Applies QoS rules instructed by SMF
- Edge Deployment: Can be deployed at network edge for MEC
- Mobility Anchor: Acts as anchor for inter-RAT mobility
- 4G Analogy: Home Subscriber Server (HSS)
- User ID: Manages user identification and addressing
- Auth Credentials: Generates authentication credentials
- Subscription Data: Exposes subscription data as a service to other NFs
- 4G Analogy: Authentication function within HSS
- Authentication: Verifies UE credentials against UDM data
- Security: Provides enhanced security with 5G AKA
- 4G Analogy: Policy & Charging Rules Function (PCRF)
- Network Slicing: Provides policy for network slicing
- Access Policies: Supplies policy rules to AMF
- Session Policies: Supplies policy rules to SMF
- 4G Analogy: None - Completely new for 5G!
- Service Discovery: Allows NFs to discover other NF instances
- Service Registration: NFs register their profiles when active
- Dynamic: Enables dynamic, flexible network architecture
- 4G Analogy: None - New for network slicing
- Slice Selection: Determines which network slice serves the UE
- Service-Based: Selection based on subscription and requested service
- 4G Analogy: None - New for third-party integration
- API Gateway: Exposes network capabilities via APIs
- 3rd Party Access: Allows trusted apps to request network services
- QoS API: External apps can request specific QoS for their traffic
Part 3: Detailed Head-to-Head Comparison
Let's examine the key architectural differences between 4G EPC and 5G Core across critical dimensions that define modern telecommunications infrastructure.
| Feature | 4G Evolved Packet Core (EPC) | 5G Core (5GC) |
|---|---|---|
| Core Architecture | Point-to-Point: Nodes connect via specific, protocol-defined interfaces (e.g., S1-MME, S11, S5/S8). The architecture is relatively rigid. | Service-Based Architecture (SBA): Network Functions (NFs) expose services via APIs. NFs communicate over a common service bus, discovering each other via the NRF. Highly flexible and modular. |
| Design Philosophy | Monolithic Network Elements: Functions are bundled into large, often hardware-based nodes (MME, SGW, PGW). | Cloud-Native & Microservices: Functions are decomposed into smaller, software-based NFs that are designed to run in containers on commodity hardware or cloud platforms. |
| Interfaces | Legacy Telecom Protocols: Primarily uses protocols like Diameter for control plane signaling and GTP for tunneling user data. | Web-Scale Technologies: Uses modern, lightweight protocols like HTTP/2 and RESTful APIs for all control plane interactions. This simplifies integration and development. |
| Control/User Plane | Coupled: The SGW and PGW combine both control plane (signaling) and user plane (data forwarding) functions. CUPS was a later addition and not native. | Fully Separated (CUPS): The Control Plane (AMF, SMF) is completely decoupled from the User Plane (UPF). This is fundamental to the architecture, enabling flexible UPF placement for edge computing. |
| Data Management | Stateful Nodes: Subscriber state and session information are tightly coupled with the nodes (e.g., MME holds mobility state, PGW holds session state). | Stateless NFs: NFs are designed to be stateless. They retrieve, process, and update data stored in a central Unified Data Repository (UDR). This makes NFs more resilient and easier to scale. |
| Key Enabler | Mobile Broadband (MBB): Primarily designed to deliver fast internet to smartphones. | Network Slicing, Low Latency (URLLC), Massive IoT (mMTC): Designed from the ground up to support diverse services with different requirements on a common infrastructure through network slicing. |
| Flexibility & Scalability | Limited: Scaling usually means adding another large, monolithic hardware box. Introducing new services is slow and complex. | Highly Flexible & Scalable: NFs can be scaled independently and automatically based on load. New services can be deployed rapidly as new microservices (NFs). |
| Exposure to 3rd Parties | Limited and Complex: Exposing network capabilities to external applications is difficult and not a core design principle. | Built-in Exposure (NEF): The Network Exposure Function (NEF) provides a secure, standardized way to expose network services via APIs, fostering innovation. |
Conclusion: A Paradigm Shift
The transition from the 4G EPC to the 5G Core represents a fundamental paradigm shift in how mobile networks are architected, deployed, and operated.
A robust but rigid architecture, a masterpiece of its time, perfectly engineered for the smartphone revolution. It is like a well-built, specialized piece of industrial machinery—powerful, reliable, but purpose-built.
An agile, software-defined platform that borrows principles from cloud computing and IT to create a network that is not just a pipe for data but a programmable service delivery platform, ready to power autonomous vehicles, AR/VR, massive sensor networks, and smart cities.
The future of telecommunications is not just about faster speeds—it's about intelligent, flexible, programmable networks that can adapt to the infinite variety of services the connected world demands.