Senior Technical Lead - Radio Intelligent Controller Systems

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.