Senior Software Engineer – Low-Latency, Async & Systems Programming | Cloud Security

Your Role:

We are looking for a true systems programmer who is obsessed with performance, concurrency, and low-overhead design. This role is for an engineer from a background in game engine development, high-frequency trading (HFT), database internals, or real-time simulation. We are looking for specialists who apply these skills in a managed environment (like C# or Java) or who come directly from a deep C/C++/Rust background.

Your mission is to write high-performance, asynchronous, low-latency code that handles massive, non-blocking throughput on a single machine. You will dig into memory profiles, hunt down GC pressure, eliminate allocations, and design highly concurrent event-driven architectures. If your first instinct for solving a performance bottleneck is to optimize an asynchronous pipeline or a data structures memory layoutrather than throwing a Redis cache at ityou are exactly who we are looking for.

Your Opportunity

• Asynchronous Optimization: Build and refine heavy asynchronous execution patterns, ensuring maximum thread efficiency and minimal latency overhead across massive workloads.
• High-Throughput Engineering: Design, develop, and maintain complex, scalable, and high-performance systems with a focus on non-blocking architectures and highly efficient, maintainable code.
• Memory & Allocation Control: Aggressively reduce memory allocations and GC pressure using profiling tools (like PerfView, dotTrace, YourKit) and advanced allocation techniques (e.g., object pooling, custom data structures, Span<T>/Memory<T>/ByteBuffer concepts).
• Root Cause Diagnostics: Identify and troubleshoot production issues, conducting low-level root cause analysis and implementing fixes to ensure strict system reliability.
• Low-Level Trade-off Analysis: Analyze and articulate the architectural trade-offs of different design choices (e.g., bitmap vs. free-list allocators, array vs. list memory layout, speed vs. memory, synchronous blocking vs. asynchronous event loops).
• Technical Leadership: Collaborate with other senior engineers to drive technical direction, fostering a culture of continuous improvement, async proficiency, and memory-aware development.

What You'll Need

• A High-Performance & Concurrency Background: A proven track record working in the performance-critical domains listed above, specifically dealing with heavy data streams or real-time processing.
• Deep Asynchronous Mastery: Practical, battle-tested experience with asynchronous, event-driven, or multi-threaded programming. You understand how non-blocking I/O works under the hood and how to avoid common concurrency pitfalls.
• Fluency in Memory & Data Fundamentals: You dont just "know" data structures; you understand how computers fundamentally process them. You can easily explain the memory layout, cache-locality, and algorithmic trade-offs of choosing one structure over another from first principles.
• Memory Management Proficiency: Instantly recognize and describe strategies for managing large, fixed blocks of memory (e.g., bitmap allocators, free lists) and mitigating memory fragmentation.
• A "Systems" Mindset: Fluent in bit manipulation and pointer/offset arithmetic. You are capable of calculating the exact metadata and memory overhead of your own code blocks.
• Advanced Performance Tuning: A great story about a time you used a memory or CPU profiler to hunt down a low-level bottleneck and solved it with a non-obvious, structural fix.
• Language Agnostic Experience: 4+ years of professional experience, primarily leveraged in performance-first environments using C++, C, Rust, C#, or Java.

And Ideally:

• Deep C/C++/Rust Instincts: A strong background in unmanaged systems programming is the best indicator of the foundational memory skills we interview for. If you work in C# or Java, you must bring an equivalent "close-to-the-metal" mindset.
• Security & Compliance: Experience in secure environments (FedRAMP, IL5/IL6) or an active security clearance.

#LI-Hybrid #LI-LP1