Skip to content
5G/6G AcademyEst. 2009
Join free
All Courses
Level 31

NF Software Engineering — Building 5G Core Network Functions

For software engineers entering telecom — learn to build, contribute to, and operate 5G core Network Functions. Master the cloud-native architecture of 5GC where NFs are services talking HTTP/2 over the SBI, walk through real Open5GS and free5GC code paths for AMF, SMF, UPF, and NRF, implement an SBI server and client in Go using 3GPP OpenAPI specifications, design NF state machines for session establishment and registration, persist subscriber state with Redis or PostgreSQL, instrument with OpenTelemetry, containerize and deploy on Kubernetes, and ship your first contribution to an open-source NF project.

20 interactive0 simulation4 labs4 quizzes
0/28 lessons

Open NF Software Engineering — Building 5G Core Network Functions free for 7 days

A new account opens this level, every other level and every certification course for 7 days — no card.

Join for free

5G Core for Software Engineers

0/7

5G core as cloud-native software — what NFs actually are, the SBI interaction model with HTTP/2 and OpenAPI, NRF as service registry, stateful versus stateless NF design, and the open-source reference implementations Open5GS, free5GC, and Magma.

5G core as cloud-native software — what NFs actually are
How 5GC departs from 4G monolithic boxes — each NF is a service, each interaction is an HTTP request, each deployment is containers.
interactive3 min
NF interaction model — SBI, HTTP/2, JSON, OpenAPI
The Service-Based Interface in plain software-engineering terms — REST-like APIs over HTTP/2 with JSON payloads defined by OpenAPI.
interactive3 min
NRF as service registry — discovery and binding
How NFs find each other in a 5GC deployment — register with the NRF, query for service producers, cache discovery results.
interactive3 min
Stateful vs stateless NF design
Why some NFs (AMF, SMF) are inherently stateful and how stateless front-ends with externalized state enable horizontal scaling.
interactive3 min
5GC reference implementations — Open5GS, free5GC, Magma
Three production-quality open-source 5GC stacks compared by language, scope, license, and contribution culture.
interactive3 min
Lab: Reading the AMF source in Open5GS
Walk through the AMF code structure in Open5GS, identify the registration handler, and trace how a UE registration becomes function calls and state transitions.
lab5 min
Quiz: 5GC for Software Engineers
Test your understanding of NFs as services, SBI, NRF discovery, and the open-source 5GC ecosystem.
quiz5 min

SBI Implementation

0/7

HTTP/2 fundamentals for SBI, navigating 3GPP OpenAPI specifications, implementing an SBI server and client in Go, authentication and TLS for service-to-service calls, and building a minimal NF skeleton from scratch.

HTTP/2 fundamentals for SBI
Why 3GPP picked HTTP/2 over HTTP/1.1 — multiplexing, header compression, server push, and what each means for 5GC traffic.
interactive3 min
3GPP OpenAPI specifications — TS 29.502, 29.518, 29.510
Where 3GPP publishes machine-readable APIs for 5GC services and how to use them with Swagger Codegen and openapi-generator.
interactive3 min
Implementing an SBI server in Go
Wiring an HTTP/2 server with chi or gorilla/mux, JSON marshaling, request validation against OpenAPI, and 3GPP error responses.
interactive3 min
Implementing an SBI client in Go
NRF discovery, retry and timeout patterns, circuit breakers, and reusing HTTP/2 connections across high-volume requests.
interactive3 min
Authentication and TLS for SBI
Mutual TLS between NFs, OAuth 2.0 access tokens via NRF, and the certificate management problem at 5GC scale.
interactive3 min
Lab: Building a minimal NF skeleton
Build a Go program that registers with the NRF, exposes a single SBI endpoint, and accepts requests from another NF.
lab5 min
Quiz: SBI Implementation
Test your understanding of HTTP/2 SBI, OpenAPI consumption, server and client patterns, and TLS/OAuth security.
quiz5 min

NF State Machines & Procedures

0/7

Modeling NF state — sessions, contexts, subscribers — as software entities, designing 3GPP procedures (registration, session establishment) as state machines, concurrency patterns in Go and Rust NFs, externalizing state with Redis and PostgreSQL, and instrumenting with OpenTelemetry.

Modeling NF state — sessions, contexts, subscribers
How a real AMF or SMF holds millions of contexts in memory and what data structures keep lookups fast.
interactive3 min
Procedural design — registration and session establishment as state machines
Translating a 3GPP TS 23.502 procedure diagram into a software state machine with clear transitions and guard conditions.
interactive3 min
Concurrency in NFs — goroutines, locks, lock-free patterns
How Open5GS uses event-driven design and how free5GC uses goroutines plus channels — different tradeoffs, same correctness goal.
interactive3 min
Persistence — Redis, etcd, PostgreSQL for NF state
Externalizing state for resilience and horizontal scale — when each backend wins and how to design schema for 5GC.
interactive3 min
Logging, tracing, metrics — OpenTelemetry for NFs
Instrumenting an NF for production observability with structured logs, OTLP tracing, and Prometheus-compatible metrics.
interactive3 min
Lab: Implementing a PDU session state machine
Walk through a Go state machine for SMF PDU session establishment with explicit states, transitions, and timeout handling.
lab5 min
Quiz: NF State Machines & Procedures
Test your understanding of state modeling, concurrency patterns, persistence, and observability in NFs.
quiz5 min

From Code to Production

0/7

Testing NFs with unit, integration, and conformance approaches; container patterns for 5GC; deploying NFs on Kubernetes (bridging to Level 21); operating NFs with health probes, graceful shutdown, and hot reload; and contributing to Open5GS or free5GC as your entry point into telecom open source.

Testing NFs — unit, integration, conformance with gNB simulators
Three test layers — unit tests for state transitions, integration tests with paired NFs, and conformance against UERANSIM or PacketRusher.
interactive3 min
Containerization patterns for NFs
Dockerfile design for Go and C NFs, image size minimization, multi-stage builds, and the security implications of running 5GC in containers.
interactive3 min
Deploying NFs on Kubernetes — bridging to Level 21
Putting your NF into a Helm chart, exposing SBI via Services, handling stateful NFs, and the gotchas Level 21 cloud-native covers in depth.
interactive3 min
Operating NFs — readiness probes, graceful shutdown, hot reload
The production-readiness checklist that separates a working NF from one that survives Kubernetes rolling upgrades and node failures.
interactive3 min
Contributing to Open5GS and free5GC — the practical onboarding
How to find a good first issue, where to ask questions, the maintainer expectations, and what makes a PR likely to land.
interactive3 min
Lab: Submitting your first patch to an open-source NF
Walk through a small Open5GS bug fix from forking the repo to opening the pull request — every step a new contributor needs.
lab5 min
Quiz: From Code to Production — Level Gate
Final level gate covering testing, containerization, Kubernetes deployment, operations, and open-source contribution practice.
quiz5 min