Principal Systems Architect & Head of Platform

Engineering at the
intersection of
bare-metal and strategy

Nearly 30 years building high-throughput systems where mechanical sympathy meets product scale. Zero-trust architectures, zero silent systemic debt.

Explore Expertise Open Source โ†—
Background
Matheus Santos

Matheus Santos

Head of Platform

Started at 14.
Still dismantling things.

I started programming out of obsessive curiosity. I wanted to dismantle things and understand how they work at the base level. Today I build at the exact intersection of low-level system mechanics, scalable architecture, and high-level product strategy.

My engineering philosophy is rooted in mechanical sympathy and semantic consistency. Over the past decade I've designed foundational platform ecosystems: from standardising Python orchestration layers to building custom zero-copy messaging kernels in Rust and C++, pushing past runtime ceilings and eliminating latency on the critical path.

I don't rely on default abstractions. I enforce execution isolation and backward planning, creating frameworks and strict CI/CD governance that empower developers to deploy into mission-critical, ACID-compliant environments without introducing silent systemic debt.

Core Competencies

What I build.
How I think.

โš™๏ธ

Systems Architecture

High-throughput distributed systems, event-driven topologies (NATS/ZMQ), and microservice boundary enforcement at scale.

โšก

Concurrency & Performance

Deep OS-level primitives: epoll/kqueue reactors, POSIX fork safety, sync/async impedance resolution, and latency optimisation in Rust, C++, and Python.

๐Ÿ”’

Data Integrity & Strategy

ACID/BASE compliance, strict tenant-scoping in multi-cloud environments, and aligning deep-tech infrastructure with product monetisation goals.

๐Ÿงญ

Engineering Leadership

Building developer culture via semantic consistency, precise taxonomies, and ADR-driven decision-making. Bridging business vision to bare-metal precision.

Technical Expertise

The tools.
Not the dogma.

Languages
Rust C++ C Python Go Java Kotlin Lisp JavaScript Bash
Message Brokers
NATS ZeroMQ RabbitMQ (AMQP/MQTT) ActiveMQ SQS (AWS)
Databases
PostgreSQL MongoDB MySQL
Frameworks
Envoxy (Python) Flask (Python) Django (Python) FastAPI (Python) Actix-web (Rust) Zapata (C++) Echo (Go) Spring (Java) EJB (Java) JPA (Java)
Open Source

Code I've
put into the world.

Envoxy Platform Framework

A Python-based modular framework for building scalable, event-driven platform ecosystems. Designed around semantic consistency and strict boundary enforcement.

Python github.com/habitio/envoxy
โ†—

Monocoque

A high-performance, Rust-native ZeroMQ-compatible messaging runtime built on io_uring. Designed to outperform libzmq while preserving Rust's memory safety guarantees. Zero-copy message handling, syscall-minimal IO, and runtime-agnostic architecture.

Rust github.com/vorjdux/monocoque
โ†—

Dux

A statically-typed compiled language with Python-like syntax and an LLVM backend. Ref-counted strings, hybrid inline/heap allocation, and a clean type system. Built from scratch to understand language design at the metal level.

C++ C LLVM github.com/vorjdux/dux-lang
โ†—

Wire Probe

A lightweight TCP telemetry agent that measures Layer 4 handshake latency with no external dependencies. Server mode uses io_uring to handle connections at ~500 KB RSS; probe mode exports RTT metrics to Telegraf or Collectd. Ships as a 370 KB statically-linked binary.

Rust github.com/vorjdux/wire-probe
โ†—

Zapata

Contributor to this C++ framework for distributed systems. High-performance, low-latency primitives for systems that can't afford the overhead of conventional approaches.

C++ github.com/naazgull/zapata
โ†—
Writing

Things I've
figured out the hard way.

2026-06 Rust Systems Networking

Safe Rust, Corrupt Wire

Rust gives you memory safety by construction and stops there. Building Monocoque, a pure-Rust ZeroMQ runtime over io_uring, made that boundary concrete: async cancellation is Drop, which cleans up your buffers and leaves your peer mid-parse. The fix has to be structural for the same reason the memory fix was.

Read โ†’
2026-06 Rust OS Systems

Hardware Is Asynchronous. Most of Our Operating Systems Still Aren't.

A thread about wire-probe turned into a long back-and-forth with someone building a from-scratch OS in Rust. One idea came out of it that I haven't been able to put down: the dominant POSIX model is a synchronous fiction layered over fundamentally asynchronous hardware, and we have spent thirty years bolting async back on rather than starting from it.

Read โ†’
2026-06 Networking Azure Rust

The ICMP Illusion: Bypassing Cloud SDN to Measure True L4 Latency

If you run stateful workloads on Azure, your ICMP telemetry may be lying to you. Under compute load, ICMP rides the contended software path while TCP's accelerated-networking datapath is unaffected, manufacturing a network bottleneck that doesn't exist at L4 or L7. How we diagnosed a persistent 4-6 ms latency floor and built wire-probe to stop trusting ping.

Read โ†’
Contact

Let's build
something precise.

Available for consulting on distributed systems architecture, platform strategy, and engineering leadership.

โŒฅ
GitHub
โ—ˆ
LinkedIn
โœ‰
Email