Select your current position
Pick a role and level — we'll show the growth path, skills and gap analysis.
Development path
Junior
0-2 years
Responsibility: Writing code in C/C++. Working with system calls. Debugging memory issues (Valgrind/ASan). Writing unit tests.
Key skills:
Middle
2-5 years
Responsibility: Performance optimization. Multithreaded programming (pthreads/std::thread). Profiling (perf). Building libraries.
Key skills:
Senior
5-8 years
Responsibility: Systems software architecture. Lock-free programming. Kernel modules. SIMD optimization. API design.
Key skills:
Lead / Staff
7-12 years
Responsibility: System architecture. Development standards. Choosing C vs C++ vs Rust. Coordination with hardware.
Key skills:
Principal
10+ years
Responsibility: Systems architecture at scale. Custom runtime. Compiler optimization. Industry standards.
Key skills:
Gap analysis: skills to develop
To reach the next level you'll need to develop:
Independently applies Bare Metal Programming in practice. Understands trade-offs of different approaches. Solves typical tasks independently.
Independently develops bare-metal systems: PLL initialization, MPU configuration, DMA transfers. Writes bootloaders and firmware for specific platforms with direct register access.
Independently conducts driver and kernel module reviews. Focuses on race conditions, error handling correctness, proper kernel API usage, and memory barriers.
Independently implements Compiler Optimization Passes. Works with IR and optimizations. Writes compiler tests.
Designs CI/CD pipelines from scratch. Configures caching for build acceleration. Uses matrix builds for multi-version testing. Sets up deployment pipelines (staging → production). Works with secrets and environment variables.
Independently implements JIT Compilation. Works with IR and optimizations. Writes compiler tests.
Designs low-latency components: applies lock-free algorithms, memory pooling, huge pages. Optimizes system calls via bypass (io_uring), configures CPU isolation and pinning.
Independently applies Real-Time Systems Design in practice. Understands trade-offs of different approaches. Solves typical tasks independently.
Applies algorithms for system software: B-tree for FS, hash tables with open addressing, cache-oblivious algorithms. Evaluates hardware-specific complexity.
Independently works with hardware interfaces: PCIe, USB, Ethernet PHY. Reads schematics, uses logic analyzer for protocol debugging, implements timing requirements.
Proficient in target CPU architecture: cache hierarchy (L1/L2/L3), TLB, branch prediction. Optimizes code for microarchitecture, understands platform memory ordering model.
Applies async I/O: io_uring for Linux, completion-based I/O, coroutines (C++20/Rust async). Designs event loop architectures.
Confidently uses debugging tools: GDB remote debugging, KGDB for kernel, JTAG for bare-metal. Applies Valgrind, AddressSanitizer for memory corruption detection.
Applies quality tools: sanitizers (ASAN/MSAN/TSAN/UBSAN), static analysis (clang-tidy), fuzzing for edge cases.
Applies concurrent programming: reader-writer locks, thread pools, atomic operations, memory ordering (acquire/release/seq_cst).
Independently designs interrupt handling systems: top-half/bottom-half, tasklet/workqueue, threaded IRQ. Configures interrupt affinity, minimizes handling latency.
Proficient in OS internals: VFS layer, process scheduler (CFS), memory management subsystem. Modifies kernel subsystems, analyzes behavior via ftrace/perf.
Designs system components with proper abstractions: HAL, platform abstraction, API contracts. Applies layered architecture for kernel subsystems and drivers.
Understands TCP/IP stack internals at the OS level — socket buffer tuning, congestion control algorithms, and kernel network parameter optimization. Configures TLS/SSL for custom protocol implementations. Works with low-level network primitives including raw sockets and packet crafting. Understands DNS resolution internals and TTL propagation. Debugs network issues using tcpdump, Wireshark, and eBPF network tracing.
Applies system patterns: Flyweight for memory optimization, Reactor for I/O multiplexing, Chain of Responsibility for packet processing.
Confidently programs in C at system level: works with function pointers, volatile, bit fields. Writes drivers and kernel modules following coding standards.
Develops real-time components: uses PREEMPT_RT, configures SCHED_FIFO/SCHED_DEADLINE, memory locking via mlockall. Measures and minimizes worst-case latency.
Independently develops on RTOS: configures scheduler, optimizes stack allocation, implements power management. Ports RTOS to new hardware platform.
Independently develops drivers: platform drivers, I2C/SPI/UART, DMA work. Uses device tree for configuration, handles interrupts and manages power state.
Independently develops firmware: implements OTA updates, dual-bank boot, watchdog recovery. Manages flash memory with wear leveling, implements persistent configuration.
Independently develops kernel modules: works with VFS, memory management API, scheduling. Understands RCU, spinlocks, completion, uses kernel debugging infrastructure.
Confidently applies synchronization in system code: spinlocks, RCU, read-write locks. Understands memory ordering (acquire/release), uses atomic operations for counters and flags.
Applies system data structures: arena allocators, intrusive lists, radix trees, concurrent hash maps. Optimizes memory layout for cache.
Manages memory: custom allocators (pool, slab, arena), memory-mapped files, huge pages. Analyzes via Valgrind and perf.
Confidently works with memory management: page allocator, slab allocator, memory mapping. Configures huge pages, understands OOM killer, debugs memory leaks via kmemleak.