Articles


This article describes the implementation of a Java-based microservice that follows the principles of Hexagonal Architecture (also known as Ports and Adapters) and can serve as a reusable template. It provides a solid foundation for building maintainable and scalable microservices.

Built with Spring Boot, the microservice offers a REST API with a clean, modular structure designed to quickly bootstrap scalable and testable services. It separates core business logic from infrastructure concerns, making the codebase easier to maintain and extend over time. Key advantages include developer productivity, separation of concerns, scalability, flexibility, and ease of testing.

  • Java
  • Spring
  • Spring Boot
  • Architecture
  • REST
  • Testing

This article describes the implementation of a Java-based ETL (Extract, Transform, Load) pipeline built with Apache Flink, designed to migrate and transform data between databases. It provides a foundation for building modern data engineering workloads, allowing developers to quickly bootstrap scalable, testable, and reliable ETL applications.

The pipeline uses a unified combination of the Flink Table/SQL API and DataStream API, offering a modular, decoupled structure. It cleanly separates declarative extraction operations from core domain mapping logic and target delivery. Preconfigured with Apache Flink, PostgreSQL, and MongoDB, it offers optimized batch execution, robust fault tolerance, highly decoupled data operations, and seamless connector swapping.

  • Java
  • Flink
  • Data
  • Architecture
  • ETL
  • Testcontainers

This article presents a Java microservice template built with Spring Boot and Apache Kafka, following Event-Driven Architecture (EDA) principles. It provides a clean foundation for building scalable and resilient distributed systems that communicate through events instead of direct service calls.

The template is designed with a modular structure, separating domain logic, messaging infrastructure, configuration, and integration boundaries to ensure a clear architectural separation between components. This makes it a reusable starting point for modern microservice ecosystems. The structure is designed to be easily extended with additional services, topics, or event flows as your system grows.

  • Java
  • Spring Boot
  • Kafka
  • Architecture
  • Testcontainers

This article presents a Java-based microservice template built with Spring Boot that follows a modern REST-based Layered Architecture pattern. It offers a practical start for developers seeking a clean, modular codebase that follows best practices in structure, readability, and maintainability.

It provides a simple structure with clearly defined layers such as controller, service, and repository, making it easy to understand, extend, and maintain. The template exposes a REST API and offers a modular, clean foundation suitable for a wide range of applications, especially those with moderate business logic. Key advantages include simplicity, separation of concerns, maintainability, testability, and practical scalability.

  • Java
  • Spring
  • Spring Boot
  • Architecture
  • REST
  • Testing

This article explains the fundamentals of Spring Beans, the building blocks of any Spring Framework or Spring Boot application. It covers how beans are created, configured, and managed by the Spring IoC Container, including their dependencies, scopes, and lifecycle.

Through practical examples and clear explanations, the article shows how to define beans with annotations or XML, use Spring stereotypes like @Component, @Service, @Controller, and @Repository, and customize bean initialization and destruction. A simple layered architecture example demonstrates how Spring Beans work together in a real application, to show how modular and maintainable Spring Boot projects can be built.

  • Java
  • Spring
  • Spring Boot
  • Beans
  • Dependency Injection

This article shows how to integrate Gravatar into a Java Spring Boot app to enhance user profiles with minimal setup. It explains how Gravatar works, how to configure it properly, and where it fits within a larger approach to managing user identity in web applications.

In today's web applications, avatars play an important role in creating personalized, visually rich user interfaces. But asking users to upload photos and repeat profile details across platforms can be tedious and time-consuming. Services like Gravatar help by providing publicly available profile data linked to a user's Gravatar account, using only their email address.

  • Java
  • Spring Boot
  • Integration
  • REST
  • Testing

In this article, I present some books that helped me design better systems and write better code. They've truly improved how I approach software development and shaped my thinking along the way. These are titles I keep returning to, use in real projects, and often recommend to others.

Writing code is just one part of building production-ready software. Designing scalable systems, communicating ideas clearly, and making thoughtful architectural decisions are equally important, if not more so, in the long run. That's why I decided to highlight a selection that covers these areas and might help other engineers build better systems.

  • Software Design
  • Architecture
  • Agile
  • Scrum
  • Learning

In this article, I share courses that helped me organize engineering work and support project management. They helped me see how engineering fits into the bigger picture and showed me how to communicate more clearly, organize work better, and stay aligned with changing priorities.

When I first started working in development, I've noticed that while many developers can solve defined problems, these problems often evolve during development. Shifting requirements frequently demand further adjustments to truly meet goals. Although navigating those constant changes wasn't officially my role, I wanted to help our team work more effectively, so I tried to find the way to deal with it.

  • Project Management
  • Agile
  • Scrum
  • Learning
  • Courses