Systems Software Engineer · Technical Lead · C++ · Distributed Systems · Cybersecurity

I'm a software engineer focused on systems programming, distributed systems, concurrency, and high-performance C++.

I currently work on the core architecture of Wazuh, designing and evolving components across the Manager and Engine data planes. My recent work includes secure agent–manager protocols, event and inventory ingestion pipelines, OpenSearch integration, shared transport infrastructure, backpressure, observability, configuration architecture, and reliability under high concurrency.

I enjoy working on problems where correctness is not only about the happy path: overload behavior, failure semantics, resource bounds, shutdown ordering, synchronization, recovery, and operability are all part of the design.

• Systems programming: C++17, Linux, multithreading, asynchronous I/O, memory and resource management
• Distributed systems: bounded queues, backpressure, sharding, group commit, retries, idempotency, graceful shutdown
• Security: TLS, JWT, authentication protocols, OpenSSL, fail-closed validation
• Data platforms: OpenSearch, Data Streams, RocksDB, FlatBuffers, CTI/IOC synchronization
• Performance engineering: profiling, benchmarking, stress testing, hot-path optimization
• Reliability: ASAN, TSAN, race-condition debugging, lifecycle and shutdown safety
• Engineering practices: architecture design, technical proposals, automated testing, CI/CD, packaging, and documentation

Replace the manager's pseudo-XML configuration parser with a schema-validated strict-XML loader

Introduced a single schema-driven effective configuration model shared across Manager daemons, Engine, Python Framework/API, installers, packages, and documentation.

Replace custom CMAC authentication with strict JWT bearer profiles

Designed strict JWT authentication and enrollment profiles with fail-closed validation, OpenSSL/HMAC-SHA256, HKDF-derived keys, and interoperable C++, Go, and Python implementations.

Unify the manager's HTTP-over-UDS servers on a shared transport

Built reusable C++17 transport infrastructure with bounded resource usage, route-class QoS, explicit backpressure, deferred responses, transport metrics, and safe two-phase shutdown.

Redesign inventory synchronization around a synchronous request/result model

Replaced a stateful multi-message synchronization protocol with a sharded, byte-budgeted pipeline using group commit, explicit HTTP outcomes, vulnerability-scan coordination, and load-testing instrumentation.

Implement the stateless HTTPS event-ingestion pipeline

Implemented authenticated event ingestion from agents to the Engine with async UDS forwarding, bounded in-flight resources, explicit backpressure, race-safe key hot reload, and graceful shutdown.

Fix token-bucket rate limiter race conditions under high concurrency

Diagnosed TOCTOU and lost-update races in a concurrent rate limiter and replaced unsafe update paths with CAS-based synchronization validated through multithreaded stress tests.

Remove the legacy rules model and introduce a new processing pipeline

Redesigned the Engine processing architecture around explicit pre-filter, decoder, enrichment, post-filter, and output stages.

C++17 · Linux · Python · Go · OpenSearch · RocksDB · OpenSSL · FlatBuffers · HTTP/TLS · Unix Domain Sockets · CMake · Docker · GitHub Actions

• LinkedIn
• GitHub