DEV Community: Sergio Gurillo Corral

An Opinionated Clean Architecture in Rust

Sergio Gurillo Corral — Thu, 15 May 2025 17:24:00 +0000

As I mentioned in my previous post, I’ve been tinkering a lot with Rust over the past few months and really enjoying the development experience it offers. Honestly, it’s been ages since learning a new language felt this fun and challenging.

During my years of experience, I’ve mostly developed web services (with Java, PHP, Node, Python...) and now also with Rust. Since architectures like hexagonal, Clean Architecture, and DDD are in high demand, I wanted to try applying all these ideas to Rust to see how they fit.

After a lot of discussion with a colleague (thank you Alberto for your patience and time spent on this) about the right design for a project, we arrived at something like this:

Business

├── business                      # Business logic layer
│   ├── Cargo.toml                 # Rust library config for business logic
│   └── src
│       ├── application            # Use cases and application logic
│       │   └── product
│       │       └── use_cases      # CRUD operations for Product
│       │           ├── create.rs
│       │           ├── delete.rs 
│       │           ├── get_by.rs 
│       │           └── update.rs
│       ├── domain                 # Pure domain model, business rules
│       │   └── product
│       │       ├── errors.rs      # Domain-specific error definitions
│       │       ├── model.rs       # Product entity (attributes and behavior)
│       │       ├── repository.rs  # Interface for product data access
│       │       ├── use_cases      # Domain logic for specific cases
│       │       │   ├── create.rs
│       │       │   ├── delete.rs
│       │       │   ├── get_by.rs
│       │       │   └── update.rs
│       │       └── value_objects.rs # Value objects related to Product
│       ├── lib.rs                 # Entry point for business library

This layer is the heart of the project, completely agnostic of any third-party dependencies. It holds all the business logic, the pure domain, and use cases representing core rules and behaviors — without letting technical or infrastructure details muddy the logic. In Rust, this separation is very clear thanks to modularity and organizing by crates.

Infrastructure

├── infrastructure                # Technical implementations (DB, events, notifications)
│   ├── README.md
│   ├── events                   # Integration with messaging/event systems
│   │   ├── Cargo.toml           # Rust library config for events
│   │   ├── kafka.rs            
│   │   └── rabbitmq.rs          
│   ├── notifications            # External notification services
│   │   ├── Cargo.toml           # Rust library config for notifications
│   │   ├── sendgrid.rs          
│   │   └── twilio.rs           
│   └── persistence              # Data persistence (databases)
│       ├── Cargo.toml           # Rust library config for DB
│       └── mongo
│           └── product
│               ├── data_model.rs   # DB data model (mapping)
│               └── repository.rs   # Mongodb repository implementation

In this layer we put all the technical implementations that support the app, like databases, messaging, or external services. Because the business layer depends only on interfaces, here we can easily swap implementations without affecting the core logic. Rust’s type system and modules help keep these dependencies clear and controlled, and also make it easy to integrate with external tech via specific crates for Kafka, RabbitMQ, or notification services.

Presentation

├── presentation                 # User interface / system entry point
│   ├── README.md                
│   ├── cli                     # Command-line interface
│   │   ├── Cargo.toml
│   │   └── src
│   │       └── main.rs          # CLI main entry point
│   ├── cron                    # Scheduled jobs (recurring tasks)
│   │   ├── Cargo.toml
│   │   └── src
│   │       └── main.rs          # Code to run cron tasks
│   └── rest-api                # REST API exposing the domain
│       ├── Cargo.toml
│       └── src
│           ├── config          # API general configuration
│           │   ├── app_state.rs
│           │   ├── settings.rs
│           │   └── tracing.rs
│           ├── lib.rs          # REST library entry point
│           ├── main.rs         # Main to launch HTTP server
│           └── router
│               └── product
│                   ├── controller.rs  # REST controllers for Product
│                   └── dto.rs         # Data transfer objects

Finally, the presentation layer is the system’s entry door, handling interaction with users or other external systems via APIs, CLI, scheduled jobs, or a playground to quickly test use cases locally. Keeping this layer separate ensures the details of how we receive or send data don’t mess with business logic or infrastructure.

Conclusion

I’m really happy with how the final design turned out. It lets me focus on the functionality and business logic without worrying about technical infrastructure details. Plus, isolating specific technologies helps reduce cognitive load and makes the project more maintainable and scalable. In short, I believe this architecture is a great way to organize a full, professional Rust project.

shop-project/
├── Cargo.toml                     # Main Rust project config file
├── business                      # Business logic layer
│   ├── Cargo.toml                 # Rust library config for business logic
│   └── src
│       ├── application            # Use cases and application logic
│       │   └── product
│       │       └── use_cases      # Operations for Product
│       │           ├── create.rs
│       │           ├── delete.rs 
│       │           ├── get_by.rs 
│       │           └── update.rs
│       ├── domain                 # Pure domain model, business rules
│       │   └── product
│       │       ├── errors.rs      # Domain-specific error definitions
│       │       ├── model.rs       # Product entity (attributes and behavior)
│       │       ├── repository.rs  # Interface for product data access
│       │       ├── use_cases      # Domain logic for specific cases
│       │       │   ├── create.rs
│       │       │   ├── delete.rs
│       │       │   ├── get_by.rs
│       │       │   └── update.rs
│       │       └── value_objects.rs # Value objects related to Product
│       ├── lib.rs                 # Entry point for business library
├── docker-compose.yml             # Docker services configuration
├── infrastructure                # Technical implementations (DB, events, notifications)
│   ├── README.md
│   ├── events                   # Integration with messaging/event systems
│   │   ├── Cargo.toml           # Rust library config for events
│   │   ├── kafka.rs            
│   │   └── rabbitmq.rs          
│   ├── notifications            # External notification services
│   │   ├── Cargo.toml           # Rust library config for notifications
│   │   ├── sendgrid.rs          
│   │   └── twilio.rs           
│   └── persistence              # Data persistence (databases)
│       ├── Cargo.toml           # Rust library config for DB        
│       └── mongo
│           └── product
│               ├── data_model.rs   # DB data model (mapping)
│               └── repository.rs   # Mongo repository implementation
├── presentation                 # User interface / system entry point
│   ├── README.md                
│   ├── cli                     # Command-line interface
│   │   ├── Cargo.toml
│   │   └── src
│   │       └── main.rs          # CLI main entry point
│   ├── cron                    # Scheduled jobs (recurring tasks)
│   │   ├── Cargo.toml
│   │   └── src
│   │       └── main.rs          # Code to run cron tasks
│   └── rest-api                # REST API exposing the domain
│       ├── Cargo.toml
│       └── src
│           ├── config          # API general configuration
│           │   ├── app_state.rs
│           │   ├── settings.rs
│           │   └── tracing.rs
│           ├── lib.rs          # REST library entry point
│           ├── main.rs         # Main to launch HTTP server
│           └── router
│               └── product
│                   ├── controller.rs  # REST controllers for Product
│                   └── dto.rs         # Data transfer objects

Rust is not so complicated after all....

Sergio Gurillo Corral — Mon, 05 May 2025 12:14:38 +0000

As you probably know, one of the most trending programming languages in recent years is Rust. You’ve likely heard it promises C-like performance with a more friendly syntax, similar to Java, TypeScript, or Python. Sounds great, right?

But as you might also know, not everything is that perfect: concepts like ownership and the borrow checker make the learning curve a bit steeper, especially if you come from higher-level languages, like I do. Still, over the past few months, I decided to give Rust a try and see what the real experience of working with it is like. Here are my takeaways:

🧑‍🏫 The compiler: a strict but fair coach

Rust’s compiler is like that tough coach who has a very specific way of doing things, but also gives you every tool you need to get better.

I’ve been playing basketball for nearly 20 years, and those were the coaches that helped me grow the most. Well, Rust feels the same: the compiler catches everything, sure, but it also tells you why, and often even how to fix it.

🛠️ The tooling is fantastic

Cargo, rustfmt, clippy... Rust comes with an ecosystem of tools that cover exactly what you need. Cargo.toml is simple—less verbose than Maven but more complete than Go’s minimalist approach.

Everything is designed so you can organize things properly from day one. The fact that it comes with a built-in linter and formatter is a huge win.

🧠 Ideal for DDD and strong domain models

Rust feels very natural when working with domain-driven design. Algebraic types, static and strong typing, and the demanding compiler help you model the domain well and prevent invalid states.

When it comes to refactoring, this robustness really shines. It’s not necessarily faster to refactor, but it feels more reliable. That’s something I don’t always get with, say, Python.

💡 Lightweight and efficient

One of the reasons I started using Rust was because I needed a lightweight dev environment. And, well... Java and Spring Boot don’t really fit that definition 😅. If you want a smooth Spring Boot setup, you’re usually running IntelliJ, Docker with a container or two... and with just 16GB of RAM, especially under WSL, it gets rough.

That’s when I started playing with Rust (and Go as well). I love both, but when your project has a complex domain, Rust offers more powerful tools. I tend to save Go for simpler use cases. Also, Rust is compiled, and while build times can grow with your project, its CPU and RAM usage is super efficient. In resource-constrained environments, that translates to lower infrastructure costs.

🤯 And the infamous borrow checker?

Ownership and the borrow checker were new concepts for me too. I had a bit of a background from tinkering with C++, but no real experience. And yeah, it does have a learning curve… but it wasn’t the nightmare I’d read about in other posts.

Plus, with tools like Copilot, Cursor, ChatGPT, Gemini, etc., it’s way easier these days. If you’ve got a solid programming foundation, AI helps speed things up a lot. And the nice thing is, since Rust is so strict, AI assistants also have less room to silently break your code. As long as you’re not blindly copying everything (no vibe coding!), you can move surprisingly fast.

It’s like thinking: “I’m coding fast... in a language that’s already fast.” Best of both worlds.

🚀 Loco.rs: Ruby on Rails, but in Rust 🤯

Loco is like having Ruby on Rails in Rust. If you don’t mind committing to a predefined architecture and want to prototype quickly, Loco is awesome. Need a CRUD or MVP? With just a few commands and some familiarity with Rust and RoR, you’ll have something running in no time.

🎯 Some downsides (because nothing’s perfect)

It can be more verbose than Python or TypeScript.
It’s pretty opinionated about how to do certain things.
Even though it doesn’t need a heavy IDE, the most-used LSP, rust-analyzer, can use quite a bit of RAM. It works with 8–16GB, but just keep it in mind.
Asynchronous programming in Rust has its own complexity (though Java isn’t exactly simple either).
The community is growing, but it’s not as mature as JavaScript, Java, or Python. That shows in the number of job offers, at least here in Spain.

So... is it worth it?

Rust isn’t a Swiss army knife of programming languages, but it is a very powerful tool. It offers a great development experience, lets you build CLI apps, backends, desktop software, even mobile apps (with Tauri, which looks really promising), and it’s resource-efficient.

And if you combine it with AI as an ally, the learning curve becomes a lot more manageable.

Rust no es tan complicado después de todo...

Sergio Gurillo Corral — Mon, 05 May 2025 12:10:38 +0000

Como ya sabrás, uno de los lenguajes más en tendencia en los últimos años es Rust. Seguro has escuchado que promete el rendimiento de C con una sintaxis más amigable, tipo Java, TypeScript o Python. Suena genial, ¿no?

Pero también sabrás que no todo es tan bonito: conceptos como ownership y el borrow checker hacen que la curva de aprendizaje sea un poco más pronunciada si vienes de lenguajes de alto nivel, como es mi caso. Aun así, estos últimos meses decidí darle una oportunidad a Rust y ver qué tal era la experiencia real trabajando con él. Estas son mis conclusiones:

🧑‍🏫 El compilador, el entrenador estricto pero justo

El compilador de Rust es como ese entrenador muy exigente, con una forma muy concreta de hacer las cosas, pero que también te da todas las herramientas para mejorar.

Llevo casi 20 años jugando a baloncesto, y estos han sido los entrenadores que más me han hecho crecer. Pues con Rust pasa algo parecido: el compilador te corrige todo, sí, pero también te explica el porqué y muchas veces hasta te sugiere cómo solucionarlo.

🛠️ El tooling es una maravilla

Cargo, rustfmt, clippy... Rust viene con un ecosistema de herramientas que cubre justo lo necesario. El Cargo.toml es simple, sin la verbosidad de Maven pero más completo que el enfoque minimalista de Go.

Todo está pensado para que puedas organizarte bien desde el minuto cero. Que traiga su propio linter y formatter por defecto ya me parece un puntazo.

🧠 Ideal para DDD y dominio fuerte

Rust se siente muy cómodo cuando trabajás con diseño orientado al dominio. Los tipos algebraicos, el tipado estático y fuerte, y el compilador exigente te ayudan a modelar bien el dominio y evitar estados no representables.

A la hora de refactorizar, esta solidez se nota un montón. No digo que sea más rápido refactorizar, pero sí me da más confianza. Algo que con Python, por ejemplo, no me pasa tanto.

💡 Ligero y eficiente

Uno de los motivos por los que empecé con Rust fue porque necesitaba un entorno de desarrollo ligero. Y Java, bueno, Spring Boot... no entraba en esa definición 😅. Si quieres trabajar bien con Spring Boot, lo normal es tener IntelliJ, Docker con algún contenedor... y eso con 16GB de RAM se sufre, más aún si estás en WSL.

Ahí empecé a trastear con Rust (y con Go también). Ambos me encantan, pero si tu proyecto tiene un dominio complejo, Rust te da herramientas más potentes. Go lo reservo para casos de uso más sencillos. Además, Rust es compilado, y aunque la compilación puede volverse más lenta a medida que el proyecto crece, en uso de CPU y RAM es súper eficiente. En entornos donde los recursos cuentan, eso significa menor coste en infraestructura.

🤯 ¿Y el famoso borrow checker?

El borrow checker y el ownership fueron conceptos nuevos para mí también. Tenía alguna noción sobre manejar memoria por haber trasteado con C++, pero sin experiencia real. Y la verdad, sí tiene curva de aprendizaje... pero tampoco fue la pesadilla que leí en otros posts.

Además, con herramientas como Copilot, Cursor, ChatGPT, Gemini, etc., hoy en día se lleva bastante mejor. Si tienes una buena base de programación, la IA te acelera muchísimo. Y lo bueno es que, al ser Rust tan estricto, incluso las IA tienen menos margen para "romperte" algo sin darte cuenta. Sin caer en el vibe coding, siendo responsable con el código que generás, se puede ir muy rápido.

Y es como pensar: “Estoy programando rápido... en un lenguaje que ya de por sí es rápido”. Lo mejor de los dos mundos

🚀 Loco.rs: Ruby on Rails, pero en Rust 🤯

Loco es como tener Ruby on Rails pero en Rust. Si no te molesta casarte con una arquitectura predefinida y quieres prototipar algo rápido, Loco es brutal. ¿Necesitás un CRUD o un MVP? Con unos cuantos comandos y algo de experiencia con Rust y RoR, ya lo tienes funcionando.

🎯 Algunas contras (porque no todo es perfecto)

A veces puede ser más verboso que Python o TypeScript.
Tiene una forma muy opinionada de hacer ciertas cosas.
Aunque no necesita un IDE pesado, el LSP más utilizado, rust-analyzer a veces consume bastante RAM. Con 8–16GB se puede trabajar, pero ojo ahí.
El manejo de asincronía en Rust tiene su complejidad (aunque Java tampoco se queda atrás en eso).
La comunidad es grande, pero no tan madura como JavaScript, Java o Python, y eso se nota en la cantidad de ofertas laborales (al menos en España).

¿Vale la pena entonces?

Rust no es la navaja suiza de los lenguajes de programación, pero sí es una herramienta muy poderosa. Tiene una excelente experiencia de desarrollo, permite hacer CLI, backend, desktop, incluso apps móviles (con Tauri, que tiene muy buena pinta) y es barata en términos de recursos.

Y si sumás la IA como aliada, la curva de aprendizaje se vuelve mucho más llevadera.

Token Devtools Inspector 👀🔑

Sergio Gurillo Corral — Tue, 02 Jan 2024 17:14:50 +0000

🙋🏻‍♂️ Have you ever found yourself copying the JWT of a request in Chrome? Whether it's to use it in Postman, inspect it in JWT, or any other task, and? Is it something you do frequently? 🤔

I do, and truth be told, the process can become a pain after so many times:

open Chrome's DevTools 🛠️
Go to the Network panel 🔍
Search for the request you are interested in 🕵️
Open the Headers section 📜
Select the entire JWT (and keep your fingers crossed that you don't copy it wrong) 🤞
Finally, copy it 📋

Now, imagine having to do this several times a day, every day! 💀

Luckily, I've created a Chrome extension that makes this a lot easier: 🌟 Token Dev Tools Inspector 🌟

With just a few clicks, streamline token extraction in Chrome DevTools:

Open Chrome DevTools 🛠️
Locate the Token Inspector panel (similar to the Console, Network or Application panels) 🔍
Find your tokens effortlessly! 🚀

As you can see, it goes straight to the point, simple but functional UI, also with direct access to jwt.io if you want to inspect the token content.

Are you worried about the privacy of a third party reading your tokens? I understand, that's why the project is Open Source so you can verify that the data doesn't go outside!
https://github.com/Guuri11/token-inspector

If you want to give it a try, here is the link to install the extension with all its information:
https://chrome.google.com/webstore/detail/token-devtools-inspector

I hope you like it, and as I said, the project is Open Source, so don't hesitate to give your feedback if you want!

Happy new year! 🎊

Token dev tools inspector 🔑👀

Sergio Gurillo Corral — Tue, 02 Jan 2024 17:13:02 +0000

🙋🏻‍♂️ Alguna vez te has encontrado copiando el JWT de una petición en Chrome? Ya sea para usarlo en Postman, inspeccionarlo en JWT, o cualquier otra tarea, y... es algo que haces con frecuencia? 🤔

Yo sí, y la verdad, el proceso puede volverse un molesto después de tantas veces:

Abre las DevTools de Chrome 🛠️
Accede al panel de Network 🔍
Busca la petición que te interesa 🕵️
Abre la sección de Headers 📜
Selecciona todo el JWT (y cruza los dedos para no copiarlo mal) 🤞
Finalmente, cópialo 📋

Ahora, imagina tener que hacer esto varias veces al día, todos los días! 💀

Por suerte, he creado una extensión para Chrome que hace esto mucho más fácil: 🌟 Token Dev Tools Inspector 🌟

Con solo unos clics, agiliza la extracción de tokens en Chrome DevTools:

Abre Chrome DevTools 🛠️
Localiza el panel Token Inspector (similar a los paneles Consola, Red o Aplicación) 🔍
¡Encuentra tus tokens sin esfuerzo! 🚀

Cómo ves, va directo al grano, UI simple pero funcional, además con acceso directo a jwt.io si quieres inspeccionar el contenido del token.

Te preocupa la privacidad de que un tercero esté leyendo tus tokens? Lo entiendo, por ello el proyecto es Open Source para que verifiques que los datos no salen al exterior!
https://github.com/Guuri11/token-inspector

Si quieres darle un intento, aquí tienes el enlace para instalar la extensión con toda su información:
https://chrome.google.com/webstore/detail/token-devtools-inspector

Espero que os guste, y como ya dije, el proyecto es Open Source, así que no dudéis en dar vuestro feedback si queréis!

Feliz año! 🎊