I am a Software Engineer specializing in Back-End development with experience in Web and Mobile solutions. With 5 years in the field, I have worked on challenging projects, developing scalable systems and user-centric applications.

Beyond coding, I also create content for my YouTube channel and share knowledge and insights on my personal blog.

Feel free to explore more about my journey and projects. Let’s exchange ideas and take on new challenges together!

Augusto Gundana Domingos

Software Engineer | Back-End Specialist | Tech Lead

About Me

You can send me a message directly through the form below or reach out to me via the social media links below.

Name

Subject

I work on developing scalable solutions, focusing on system creation and maintenance. Besides writing code, I contribute to defining architectures and best development practices. I also mentor colleagues and continuously improve internal processes, including CI/CD (Continuous Integration and Deployment).

I lead the development team, ensuring projects are delivered with quality and aligned with community objectives. My role involves task coordination, code review, technical guidance, and helping team members enhance their skills. Additionally, I actively work on implementing new features and solutions for the systems developed.

I worked on the development and evolution of the Back-End of a payment platform, ensuring transaction efficiency and security. I used Django to create reliable APIs, ensuring integration with banking systems and other financial services. Additionally, I developed automated tests to guarantee code quality.

Professional Experience

Augusto Domingos

A Django library that automates the generation of CRUD API endpoints with Django Ninja. It dynamically scans your Django models and creates Pydantic schemas for listing, detailing, creating, and updating records—all while allowing you to customize behavior via hook functions (controllers) and schema configurations.

Lazy Ninja

Alerta EDM is a web application that informs the Mozambican population about scheduled power outages in different regions of the country. With a simple and intuitive design, it extracts data from the EDM website and allows users to filter outages by date and province.

Alerta EDM

Check out this small mini-shop with full payment functionality using the Braintree API. I used Django for the Backend and React for the Frontend, ensuring a great user experience.

Mini Shop

My Projects

Latest articles and tutorials

Blog



Lately, as I’ve been going deeper into low-level programming and reverse engineering, I ended up stumbling into something I had heard about for years but never really tried to understand properly: Denuvo.

Like most people, I only knew it by reputation. Hard to crack, controversial, sometimes blamed for performance issues. But at some point I stopped caring about the noise around it and started asking a different question.

What is it actually doing under the hood?

The more I looked into it, the more I realized that Denuvo is not really about blocking access. It is about making the program hard to understand in the first place.

One of the ideas that stood out to me early on was code virtualization.

Instead of letting the CPU execute certain parts of the program directly, those parts are transformed into something else entirely. A custom bytecode that gets interpreted at runtime. 
![](/images/blog/2aa4f625-6535-43b8-8f15-51210ba0666f.png)
So when you open the binary expecting to see logic, what you actually see is an interpreter and a bunch of data that only makes sense to it.

That shift alone changes everything. You are no longer reading code. You are trying to understand a machine that is running code.

And it gets even more interesting when you realize that this “machine” is not fixed. It can change between implementations. So even if you understand one case, that knowledge does not necessarily transfer cleanly to another.

Another thing that really changed how I think about it is the absence of a single point of failure.

I used to imagine something like a central check. If you find it, you’re done. But that’s not how it works. The checks are spread across the entire execution. Some happen early, others much later, sometimes in places that do not look important at all.

It feels less like a lock and more like a system that constantly verifies itself.

Then there is the environment.

The program is not just running. It is observing. Timing, execution patterns, system characteristics. It is constantly trying to answer a simple question: does this look like a normal machine running normally?

If the answer is no, things start to break. Sometimes loudly, sometimes in ways that are hard to trace back.

And then there is integrity. Parts of the program checking other parts. Small changes can cascade into problems much later. Which makes naive approaches unreliable.

At some point, while reading through an independent technical analysis of a modern bypass, something clicked for me.

The interesting part was not the techniques themselves, but the mindset behind them. Instead of trying to remove all of this complexity, the approach was to work around it. To make the environment look exactly how the system expects it to look, so that everything just… passes.

That idea stuck with me.

Because it highlights something deeper. Systems like this are not just protecting code. They are defining expectations about how that code should behave in the world.

And if you can control those expectations, you can change the outcome.

What I find most valuable in all of this is not the specifics of any implementation, but the perspective it gives.

It forces you to think beyond functions and files. You start thinking in terms of execution, environment, and interaction with the system as a whole.

For me, this has been one of those moments where studying something specific ends up changing how you think about programming in general.

Especially now that I am learning Rust and going deeper into low-level concepts, this kind of exploration makes everything feel more connected.

Less about writing code, and more about understanding what really happens when that code runs.


Blog

How Denuvo Works: A Technical Perspective

How Denuvo Works: A Technical Perspective