Spoiler: we're a resource
A personal reflection on autonomy, leadership and the place of those who build software in a market where AI makes generating code increasingly cheap, while judgment remains expensive.
Read →Software engineer
I enjoy exploring and understanding how the tools we use every day work. More about me →
No articles match your search.
Spring Batch — Architecture: More Domain, Less Infrastructure
Three techniques to stop Spring Batch from taking over the center of your application: a factory that centralizes common job configuration, a reusable generic reader, and a writer that only materializes the actions the domain decided on.
Read →Building a high-availability API with Spring Boot and RabbitMQ
How a Spring Boot API handles over 7 million requests a day without scaling vertically or horizontally: asynchronous event processing and batching with RabbitMQ to collapse database connections, validated with a K6 load test.
Read →Spring Batch — Practical advice for robust and fast data jobs
Performance and scaling in Spring Batch: parallel flows, step partitioning, and the memory and database considerations —heap, connection pools, ORM vs native SQL— that keep big data jobs fast and stable.
Read →Spring Batch — Introduction
An introduction to Spring Batch: jobs, chunk-oriented and tasklet steps, readers, processors and writers, fault tolerance, and how listeners and metadata tables make batch processing observable.
Read →Gradle — Speed, modularity and control in your builds
How Gradle works under the hood —directories, core concepts, the build lifecycle, key files and properties— and how to use it to enforce a hexagonal architecture across modules.
Read →Java — JVM, JDK, JRE & memory
Understanding how Java works under the hood —JDK, JRE, JVM, JIT, memory and the Garbage Collector— to make better design decisions, optimize performance and reduce infrastructure costs.
Read →Notes app — Asynchronous communication with Kafka
How to integrate Apache Kafka into a Spring project to communicate microservices asynchronously and solve the cascading deletion of a user and their notes across two databases.
Read →Notes app — CQRS: separating reads and writes
How the CQRS pattern separates read and write operations to scale an application horizontally, starting from a real database connection-exhaustion problem.
Read →Notes app — Data modeling in MongoDB: SQL vs NoSQL
Normalize or denormalize: how data modeling changes when you move from a SQL mindset to a NoSQL one in MongoDB, with the real example of folders and notes from the notes app.
Read →Notes app — Architecture on the frontend?
Thoughts on how to structure a React frontend project: decoupling HTTP calls, wrapping react-query in your own hooks, and applying the repository pattern on the client.
Read →Notes app — DDD and hexagonal in Spring
How to combine Spring's conveniences with Domain-Driven Design and hexagonal architecture: value objects, an exception hierarchy, and mapping between entities and domain models.
Read →