From professional competition and low-level C internals to resilient cloud infrastructure. Understanding the mental models that shape how I build and debug distributed systems.
My path into engineering wasn't linear. For a decade, I competed in environments where making fast decisions under pressure was a daily requirement.
That mindset naturally drew me toward systems engineering: understanding how things work under the hood, finding where they break, and building them to remain predictable and resilient.
For five years, I competed professionally in League of Legends as Eledion across LLN (Latin America) and Superliga (Spain). It required relentless match analysis, macro strategy, and real-time execution under incomplete information.
Competing at the top level taught me to evaluate decision quality over short-term variance, while sharpening concise communication under high pressure. It laid the foundation for dissecting complex failure modes with structured, root-cause analysis.
Poker brought a different kind of competition: solo, probability-driven, and centered on strict risk management under incomplete data.
It reinforced a core principle that directly translates to distributed infrastructure: a good decision doesn't always yield a good short-term outcome, and a bad outcome doesn't mean the original architecture was wrong.
I entered 42 School through the Piscine—a 26-day immersion bootcamp with zero lectures or manuals, spending 14-hour days debugging C scripts and peer-evaluating code strictly in POSIX terminal environments.
Moving into the main curriculum meant working directly with foundational low-level primitives: processes, heap memory allocation, signals, thread concurrency, POSIX sockets, and protocol handling. It built a hands-on mental model of how operating systems and networks behave when things fail.
That low-level foundation naturally led me to infrastructure. I became fascinated with how systems surrounding applications are provisioned, monitored, scaled, and recovered.
Today I bring that same first-principles rigor to cloud architecture: building automated CI/CD pipelines, containerized environments, and declarative infrastructure that eliminate manual friction and failure points.
Today, I operate at the intersection of low-level systems, cloud infrastructure, and automation—turning complex, unpredictable failure modes into simpler, self-healing systems.