Software Engineer

Secpod Technologies; Bengaluru; On-site; INR 2,800,000 - 4,000,000; Full time

Job summary

Secpod Technologies in Bengaluru, India, is seeking a Senior C++ Systems Engineer to re-architect and rebuild cross-platform monitoring agents for Linux, macOS, Windows, and AIX.

You will own system-level design, implement high-performance code, and collaborate with product teams to define roadmaps, while ensuring portability and CI/CD readiness.

This role requires deep knowledge of OS internals, multithreading, and modern C++ standards, with a focus on low-overhead, reliable telemetry.

Qualifications

• 5+ years of professional C++ development experience.
• Strong knowledge of OS internals: memory management, process scheduling, IPC, system calls.
• Experience with filesystem monitoring APIs on at least two platforms.
• Cross-platform native software experience on Linux and Windows.
• Multithreaded programming and synchronization primitives.
• Build systems familiarity, especially CMake; Makefiles on UNIX.
• Debugging and profiling with GDB/LLDB/WinDbg/Valgrind/Perf.
• Experience with unit/integration testing (Google Test, Catch2, Boost.Test).
• Git workflows, code reviews, and CI/CD pipelines.
• Ability to read and refactor legacy C++ with minimal documentation.

Responsibilities

• Lead cross-platform C++ monitoring agent architecture and development.
• Migrate code to modern C++ standards (C++17/20) with clean design.
• Implement high-performance, testable C++ components following SOLID.
• Define feature roadmaps with architecture and product teams.
• Design and implement filesystem monitoring using platform-native APIs.
• Develop real-time file-change detection with low overhead.
• Implement process lifecycle monitoring across Linux/macOS/Windows/AIX.
• Build Windows Registry change monitoring and deduplicate events.
• Provide platform-abstracted core with OS-specific back-ends via guards.
• Ensure CI/CD readiness and cross-compile builds (CMake).

Skills

Modern C++

OS internals

Multithreading

Cross-platform

Build systems (CMake)

Debugging & profiling

Unit testing

Git & CI/CD

Legacy C++ refactoring

Code reviews

Tools

GDB

LLDB

WinDbg

Valgrind

perf

strace/dtrace

Job description

Senior C++ Systems Engineer

We are looking for a passionate and highly skilled Senior C++ Systems Engineer to join our core engineering team. In this role, you will be responsible for re-architecting and rebuilding our suite of cross-platform monitoring agents - currently written in C++ - to meet the demands of modern, high-performance, and scalable infrastructure environments.

You will work at the intersection of system-level programming, OS internals, and distributed agent design, ensuring our agents deliver reliable, low-overhead monitoring across Linux, macOS, Windows, and AIX platforms. If you live and breathe systems programming and get excited about pushing performance boundaries, this role is for you.

Responsibilities

Agent Re-Architecture & Development

• Lead the design and re-architecture of cross-platform C++ monitoring agents from the ground up, ensuring modularity, performance, and maintainability.
• Evaluate existing agent codebases, identify technical debt, and define migration strategies to modern C++ standards (C++17/20).
• Implement clean, testable, and high-performance C++ code following established design patterns and SOLID principles.
• Collaborate with architecture and product teams to define agent feature roadmaps and technical specifications.

Filesystem Monitoring

• Design and implement filesystem monitoring components using platform-native APIs: inotify / fanotify (Linux), FSEvents / kqueue (macOS), ReadDirectoryChangesW (Windows), and AIX-specific equivalents.
• Develop efficient file-change detection with minimal overhead, supporting real-time event streams for file create, modify, delete, rename, and permission change events.
• Handle edge cases such as deep directory watches, high-volume event bursts, and symbolic link traversal across platforms.

Process Monitoring

• Build robust process lifecycle monitoring using /proc (Linux), kinfo_proc / sysctl (macOS), toolhelp/PSAPI (Windows), and AIX process accounting APIs.
• Track process creation, termination, CPU/memory consumption, and inter-process relationships (parent-child trees).
• Implement low-latency event notifications for process state transitions without excessive polling.

Registry Monitoring (Windows)

• Implement Windows Registry change monitoring using RegNotifyChangeKeyValue and related Win32 APIs.
• Design efficient registry watch trees with support for key-level and value-level change detection.
• Ensure reliable event delivery and deduplication under high-frequency registry modification scenarios.

Cross-Platform Engineering

• Write platform-abstracted agent core logic with clean OS-specific back-end implementations using preprocessor guards and abstract interfaces.
• Ensure binary compatibility, packaging, and CI/CD pipeline support across Linux (x86_64, ARM), macOS (Intel + Apple Silicon), Windows (x86_64), and AIX (POWER).
• Author platform-specific build configurations using CMake with cross-compile toolchain support.

Required Qualifications

Core Technical Skills

• 5+ years of professional C++ development experience, with deep expertise in modern C++ (C++11/14/17 required, C++20 preferred).
• Strong grasp of OS internals: memory management, process scheduling, IPC mechanisms, system calls, and kernel interfaces.
• Proven hands-on experience with filesystem monitoring APIs on at least two of the four target platforms.
• Experience developing cross-platform native software that runs on Linux and Windows (macOS and/or AIX exposure is a plus).
• Familiarity with multi-threaded programming, synchronization primitives (mutexes, condition variables, atomics), and lock-free data structures.
• Strong understanding of build systems - CMake preferred; experience with Makefile-based builds on AIX/Linux.
• Proficiency with debugging and profiling tools: GDB, LLDB, WinDbg, Valgrind, perf, strace/dtrace.

Software Engineering Practices

• Solid experience writing unit and integration tests using frameworks such as Google Test, Catch2, or Boost.Test.
• Comfort with Git-based workflows, code review, and CI/CD pipelines (Jenkins, GitHub Actions, or similar).
• Ability to read, understand, and refactor legacy C++ code with minimal documentation.

Preferred Qualifications

• Experience working with AIX OS internals (POWER architecture, SMIT, ODM, AIX process APIs).
• Exposure to eBPF / kernel tracing mechanisms on Linux for lightweight observability.
• Knowledge of endpoint security, EDR, or SIEM agent architectures.
• Experience with agent-based distributed systems and telemetry pipelines.
• Familiarity with Rust or Go as supplementary system programming languages.
• Contributions to open-source system-level projects are a strong plus.