I’m a software developer and Computer Engineering student at UFMS, interested in building software that is reliable, efficient, maintainable, and actually useful.

My main ecosystem is C# / .NET, but I enjoy going deeper into systems programming with Rust and C++, working with Linux infrastructure, embedded devices, databases, networking, and performance.

I like understanding what happens underneath the abstractions I use — from HTTP APIs and database queries all the way down to memory management, operating systems, networking, and hardware.

🌐 Portfolio: joao.ortega.dev.br

Backend Engineering       ███████████████████░
C# / .NET                 ███████████████████░
Software Architecture     █████████████████░░░
Testing & Reliability     ██████████████████░░
Linux & Infrastructure    ████████████████░░░░
Systems Programming       ███████████████░░░░░
Databases                 ████████████████░░░░
Embedded / IoT            ██████████████░░░░░░

I particularly enjoy working on:

• Backend architecture with C# and ASP.NET Core
• Designing clean and predictable REST APIs
• Automated testing, including unit and integration tests
• Finding race conditions, bottlenecks, memory issues, and concurrency problems
• Building telemetry and observability into applications
• Linux servers, containers, reverse proxies, and self-hosted infrastructure
• Performance-oriented programming with Rust and C++
• Databases, data modeling, and application persistence
• Networking and distributed systems
• Embedded development with ESP32 and Raspberry Pi
• Security-conscious software design

I care more about choosing the right solution than the most fashionable one.

A few principles I try to follow:

Simple systems are easier to understand, test, debug, and maintain.

Performance matters — but measure before optimizing.

Tests aren't just for finding bugs. They give you the confidence to change software.

Abstractions are useful, but understanding what happens underneath them makes you a better engineer.

Architecture should solve problems, not create them.

I enjoy questioning design decisions, benchmarking alternatives, and understanding the trade-offs behind different technologies rather than treating frameworks or architectures as universally correct.

A data tracking and visualization platform built around C#/.NET, with a strong focus on architecture, testing, and maintainability.

Some of the areas I've explored through this project:

• ASP.NET Core
• REST APIs
• Avalonia UI
• SQL databases
• Repository patterns
• Automated testing
• Telemetry
• Concurrency
• Performance analysis

A large part of the project has been developed with a test-driven mindset, allowing architectural changes and refactoring with much greater confidence.

A password management system running on my own Raspberry Pi.

Built using:

• C#
• ASP.NET Core
• MariaDB
• AES-256 encryption
• Linux
• systemd
• Docker
• Telegram integration

This project combines several things I enjoy: backend engineering, infrastructure, networking, Linux, databases, and security.

My portfolio isn't just a static page — it's also one of my infrastructure playgrounds.

joao.ortega.dev.br

The stack includes:

• ASP.NET Core
• Blazor
• Docker
• NGINX
• Cloudflare
• Raspberry Pi
• Linux
• MariaDB

I use it to experiment with deployment strategies, containerization, networking, security, monitoring, and application architecture.

An embedded automation project using ESP32-C3 devices and Rust.

The system monitors temperatures and automatically controls pool heating based on environmental conditions.

It involves:

ESP32-C3
    │
    │ HTTP / Network Communication
    ▼
Raspberry Pi
    │
    ├── Temperature processing
    ├── Automation rules
    └── Device coordination

Technologies include:

• Rust
• ESP32
• Embedded development
• HTTP
• Tokio
• Raspberry Pi
• Sensors
• Hardware control

Rust and C++ are where I explore topics closer to the machine:

• memory management
• ownership
• lifetimes
• stack vs heap
• move semantics
• concurrency
• multithreading
• cache behavior
• compiler optimizations
• performance benchmarking

I'm particularly interested in how operating systems manage:

• processes
• threads
• memory
• synchronization
• scheduling
• filesystems
• system calls
• hardware resources

I enjoy benchmarking and comparing implementation strategies rather than assuming one language or architecture will always be faster.

I've experimented with performance comparisons involving:

Rust
C++
Python
Lua

across different CPU architectures and systems.

Testing is an important part of how I develop software.

I regularly work with:

• Unit tests
• Integration tests
• Test-driven development
• Code coverage
• Regression testing
• Dependency isolation
• Refactoring supported by tests

For me, a good test suite is one of the most valuable tools for keeping a growing codebase maintainable.

I enjoy running and maintaining my own infrastructure.

My projects frequently involve:

Linux
├── Fedora
├── Debian
│
Docker
├── ASP.NET Core services
├── Databases
└── Reverse proxies
│
NGINX
│
Cloudflare
│
└── Raspberry Pi servers

Running software yourself teaches you very quickly that development doesn't end when the code compiles.

Deployment, networking, security, observability, backups, configuration, and reliability are all part of building software.

I'm always trying to understand another layer of the stack.

Current areas of interest include:

• Advanced .NET and C#
• Rust
• Modern C++
• Operating systems
• Distributed systems
• Software architecture
• Cybersecurity
• Networking
• High-performance computing
• Embedded systems
• Cloud architecture
• AI-assisted development

I enjoy learning from both theory and experimentation.

Instead of only reading about a concept, I usually end up building something with it.

That might mean:

Read about concurrency
        ↓
Implement it
        ↓
Benchmark it
        ↓
Break it
        ↓
Debug it
        ↓
Understand it better

Some of the areas I've studied include algorithms, graph theory, operating systems, object-oriented programming, modern C++, statistics, computer architecture, and embedded systems.

I'm always interested in conversations about:

C# • .NET • Rust • C++ • Linux • Backend Engineering • Software Architecture • Performance • Distributed Systems • Embedded Systems • Cybersecurity

🌐 Portfolio

💻 Check out my repositories below to see what I'm currently building.

Build things. Measure them. Break them. Understand them. Improve them.