Join us as we lead the future of telecommunications, driving innovation through green and sustainable networks. Learn more about our mission, vision and values.
We are looking for a Senior Technical Lead who is comfortable operating across the entire system, from low-level Linux and networking problems to the architecture of large Go and Kubernetes-based distributed systems.
This role is for someone who can investigate a Linux kernel or networking issue in the morning, review a concurrency problem in Go before lunch, design a multi-service distributed flow in the afternoon, and help debug a C++ component when production behavior does not match expectations.
You do not need to be the deepest specialist in every technology we use. You do need the technical range, curiosity, and systems thinking to move between layers quickly and understand how they affect one another.
Our team owns RIC Systems end to end, including Near-RT RIC, Non-RT RIC, infrastructure, messaging, state management, network-facing components, microservices, deployment, performance, reliability, and production troubleshooting.
We are looking for someone who wants that breadth.
What You'll Do:
Take technical ownership across Near-RT RIC and Non-RT RIC systems, helping define architecture, reliability, scalability, and engineering direction.
Design and develop production backend services, primarily in Go, as part of a large distributed system composed of dozens of interacting services.
Move comfortably across the stack, from Linux, networking, sockets, containers, and system performance to application-level architecture and distributed system design.
Lead the design of complex multi-service flows involving messaging, distributed state, concurrency, retries, backpressure, ordering, consistency, and failure recovery.
Build and operate systems using technologies such as Kafka, NATS, Redis, Kubernetes, and comparable distributed infrastructure.
Debug difficult production issues that cross boundaries between application code, operating systems, networking, containers, infrastructure, and service architecture.
Investigate performance using real system behavior and production data, including throughput, latency, CPU, memory, queue depth, connection counts, scheduling behavior, and service saturation.
Read, understand, and debug C++ components when issues cross into lower-level parts of the system.
Lead architectural changes, major migrations, performance improvements, and reliability initiatives that span multiple teams and dozens of services.
Review designs for critical areas including messaging, state management, service communication, resource usage, observability, and system failure modes.
Define technical standards across the RIC Systems codebase and help ensure that architectural decisions remain coherent as the system grows.
Act as the technical escalation point for problems that do not fit neatly inside a single service or technology.
Mentor engineers working across Go, C++, Kubernetes, networking, distributed systems, and infrastructure.
What We're Looking For:
8+ years of professional software engineering experience, with significant hands-on experience building complex production systems.
4+ years of strong production experience with Go, especially backend services, concurrency, networking, and distributed systems.
Experience designing, building, and operating systems composed of many interacting microservices, preferably on Kubernetes.
Strong Linux fundamentals and the ability to debug problems involving processes, threads, memory, CPU, file descriptors, sockets, networking, containers, and system resources.
Strong understanding of Kubernetes, including networking, service communication, resource management, deployments, failure modes, scaling, and production troubleshooting.
Experience with high-throughput distributed systems using Kafka, NATS, Redis, or comparable messaging and state technologies.
Deep understanding of concurrency and distributed-system behavior under load, including synchronization, contention, backpressure, retries, ordering, consistency, timeouts, and failure recovery.
Experience working with meaningful production scale and the ability to discuss it quantitatively, such as messages per second, request rates, latency percentiles, queue depth, CPU and memory utilization, connection counts, data volume, or similar metrics.
Strong system-design skills. You should be able to whiteboard a multi-service architecture, explain how requests and data move through the system, identify failure modes and bottlenecks, and defend the trade-offs you make.
Strong production-debugging skills across logs, metrics, tracing, profiling, packet captures, Linux tools, and application-level instrumentation.
Ability to read and debug C++ when necessary. C++ does not need to be your primary development language.
A track record of leading complex technical initiatives from design through implementation and production rollout.
The ability to switch quickly between abstraction levels, from architecture to code to operating-system behavior, without losing sight of how the whole system fits together.
Strong communication skills and the ability to lead technical discussions across different engineering disciplines.
Nice to Have:
Experience with telecom, mobile networks, or other complex networking systems.
Experience with Near-RT RIC, Non-RT RIC, O-RAN, 5G, or 4G RAN.
Familiarity with SCTP, ASN.1, E2AP, or other binary and wire-level protocols.
Deeper hands-on C or C++ experience.
Experience investigating Linux kernel, networking stack, or container-runtime issues.
Experience building custom messaging, routing, event-processing, or distributed state infrastructure.
Experience with high-performance or latency-sensitive network functions.
What We Offer:
This role is not for someone who wants to work exclusively at one layer of the stack.
It is a strong fit for an engineer who enjoys understanding why the entire system behaves the way it does.
You may need to trace a problem from a Go service, through Kubernetes networking, into the Linux networking stack, across a messaging layer, and eventually into a C++ component. On another day, you may be designing how 30 services coordinate state or reviewing the architecture of a new Non-RT RIC capability.
The common thread is systems thinking.
You should enjoy moving between details and architecture, debugging and design, software and infrastructure.
Why This Role
Few engineering roles offer this combination of breadth and technical depth.
You will work on:
Near-RT and Non-RT RIC Systems
Large-scale distributed backend architectures
Go and C++ software
Kubernetes and containers
Linux systems and networking
High-throughput messaging
Distributed state and concurrency
Real-time and non-real-time processing
Performance and production reliability
Systems connected to live mobile networks
You will have significant influence over both the architecture of the RIC Systems and the way the engineering organization builds and operates them.
If you are the kind of engineer who naturally moves from a system diagram to source code to perf, tcpdump, Kubernetes, and back to architecture, this is the kind of role we are building.
