About Me

I started building before I understood what "software engineering" meant. Around age 12, I was creating Roblox games. At the time, it was just experimentation — modifying mechanics, scripting behaviors in Lua, trying to understand how virtual systems responded to logic. I wasn't thinking about architecture or performance. I just wanted control over how things behaved.

That phase lasted roughly a year or two. What it really gave me wasn't game development experience — it gave me exposure to structured logic and the idea that systems operate on rules. If you understand those rules, you can shape outcomes.

Around 14, I transitioned into Python scripting, which I worked with for approximately three years. That's when programming became serious. I started building tools, automation scripts, and backend-style experiments. I learned about APIs, data handling, scripting workflows, and basic infrastructure patterns.

But more importantly, I started asking different questions:

• → Why does this consume so much memory?
• → What actually happens when multiple processes run?
• → Why does concurrency fail in subtle ways?
• → How does the operating system coordinate everything underneath?

The curiosity shifted from "how do I build this?" to "how does this work internally?"

By 15–16, I was moving deeper into backend systems and infrastructure thinking. I explored databases, authentication systems, logging architecture, and performance trade-offs. Clean design started to matter. Maintainability started to matter. Security started to matter.

Eventually, abstraction wasn't enough. I wanted more control. That's when I began working with Rust, Go, C, and TypeScript — focusing on backend services, systems-level thinking, and secure software design. Rust especially reshaped how I think about memory safety and concurrency. Systems programming forced discipline. You cannot ignore performance costs. You cannot ignore ownership. You cannot ignore undefined behavior.

Now at 17, my focus sits at the intersection of cybersecurity, systems programming, backend infrastructure, and performance-aware architecture.

I learn by building real systems — compilers, tooling, infrastructure experiments — because understanding behavior at the lowest level changes how you design at the highest level.

What started as scripting game logic evolved into studying memory models and operating-system behavior. The tools changed. The curiosity stayed consistent.