Week 11 of #100DaysOfCode: Learning and Building Microservices with Spring Boot

Introduction

This week has been another challenging but rewarding part of my #100DaysOfCode journey.

I moved from learning Microservices Architecture and related architectural styles into the more practical side of building Microservices with Spring Boot.

I explored Spring WebFlux, Reactive Streams, RabbitMQ, OAuth2, CORS, Swagger, and Spring Boot Actuator, while also learning about security, messaging, monitoring, and asynchronous communication.

I also started building and testing a simple Spring Boot Microservice, which helped me connect the theory I had been learning with practical implementation.

Some of these concepts were challenging, but they are helping me understand that backend engineering is not just about writing code. It's also about understanding architecture, scalability, security, communication, and monitoring.

I'm still learning, building, applying, and looking for opportunities to grow. One step at a time. 💙

"Great things are done by a series of small things brought together."

— Vincent van Gogh

Day 66: Exploring Related Architecture Styles

On day 66, I continued the Related Architecture Styles and Use Cases chapter and explored how different architectural approaches are used in modern software systems.

What I Learned

• Lambda Architecture and its applications in Big Data and IoT

• How DevOps, Cloud, and Containers work together with Microservices

• Reactive Microservices

• Conway's Law and the connection between organizational structure and software architecture

• Monolithic migration as a common Microservices use case

One concept that stood out to me was Conway's Law. It made me think about how the way teams and organizations are structured can influence the architecture of the software they build.

This section helped me understand that software architecture isn't only about technology. Organizational structure, development practices, and the way systems are deployed can also have a major influence on how applications are designed.

Another day of learning and getting a better understanding of how these architectural concepts connect in real-world systems.

Day 67: Starting Microservices with Spring Boot

On day 67, I started a new chapter: Building Microservices with Spring Boot.

This chapter moves from the Microservices theory I've been learning into more practical implementation using Spring Boot.

I didn't get to do much today, but I went through the beginning of the chapter and looked at what I'll be covering, including:

What I Learned

• Building RESTful Microservices with Spring Boot

• Spring WebFlux and reactive Microservices

• Securing Microservices with Spring Security and OAuth2

• Documenting Microservices with Swagger

• Using Spring Boot Actuator for production-ready applications

I've already worked with some of these technologies before, so I'm looking forward to seeing how they come together when building actual Microservices.

This chapter feels like a shift from simply understanding what Microservices are to actually learning how to build them with Spring Boot.

Day 68: Building My First Spring Boot Microservice

On day 68, I continued the Building Microservices with Spring Boot chapter and started getting more hands-on.

I set up my Spring Boot development environment and started building and testing a simple Spring Boot microservice.

What I Learned

• How @SpringBootApplication brings together configuration, auto-configuration, and component scanning

• How to test a Spring Boot microservice using tools such as curl and Postman

• HATEOAS and how it can be used to include navigation links in REST responses

• HAL, a JSON-based format for representing hyperlinks between resources

This was a good step from the Microservices theory I've been learning into actually building with Spring Boot.

I'm looking forward to going deeper into the practical side of Microservices as I continue through the chapter.

Day 69: Exploring Reactive Microservices

On day 69, I continued the Building Microservices with Spring Boot chapter, focusing on Reactive Spring Boot Microservices.

What I Learned

• How reactive principles can improve resource efficiency and scalability

• Building reactive microservices with Spring WebFlux

• Using messaging servers such as RabbitMQ

• WebFlux's annotation-based and functional programming approaches

• How Mono fits into reactive request handling

This gave me a better understanding of how modern backend systems can handle asynchronous and non-blocking operations.

I'm continuing to connect the concepts I've learned about reactive systems with practical Microservices development.

Day 70: Reactive Streams and Microservice Security

On day 70, I continued the Building Microservices with Spring Boot chapter, focusing on Reactive Streams and securing Microservices.

What I Learned

• The four Reactive Streams interfaces: Publisher, Subscriber, Subscription, and Processor

• How RabbitMQ can be used for messaging in Microservices

• Securing Microservices with Basic Security

• Using OAuth2 to secure protected resources

One thing that stood out to me was how OAuth2 separates the responsibility of authenticating clients from protecting resources.

I'm gradually getting a better understanding of how reactive communication and security fit into Microservices architecture.

Day 71: CORS, Actuator, and Monitoring

On day 71, I continued the Building Microservices with Spring Boot chapter and focused on CORS and monitoring Microservices.

What I Learned

• Enabling CORS for cross-origin communication using @CrossOrigin

• Using Spring Boot Actuator to monitor and manage Microservices

• Exploring Actuator endpoints such as health, metrics, mappings, info, and dump

• Monitoring applications using JConsole and SSH

• Creating custom health checks and metrics

This section helped me understand that building an application is only part of the job. Monitoring its health, performance, and behavior is also important, especially when running services in production.

Another step forward in understanding the practical side of building and managing Microservices.

Goals for Week 12

As I move into Week 12, I want to focus more on turning the Microservices concepts I've been learning into practical skills.

Here are my goals for Week 12:

• Continue building and practicing Spring Boot Microservices

• Deepen my understanding of Spring Security and OAuth2

• Practice Reactive Programming with Spring WebFlux

• Learn more about RabbitMQ and asynchronous communication

• Practice using Spring Boot Actuator for monitoring and observability

• Continue practicing LeetCode and improving my problem-solving skills

• Continue with mock technical interviews and improve how I explain my solutions

• Keep applying for backend engineering opportunities

• Review Java, Data Structures, and Algorithms for technical interviews

• Continue improving and revisiting my existing projects

• Stay consistent with #100DaysOfCode and continue documenting my journey

This past week, I moved further from understanding Microservices only from an architectural perspective to exploring how they can actually be built and managed with Spring Boot.

I worked with concepts around reactive programming, messaging, security, CORS, and monitoring, while also getting hands-on with building a simple Spring Boot Microservice.

There's still a lot for me to understand, but I'm gradually connecting the different pieces and becoming more comfortable with backend system design.

Going forward, I want to focus more on building, practicing, and applying what I learn.

Still learning. Still building. Still showing up.

Let's keep building. 💙

Connect With Me

LinkedIn:
https://www.linkedin.com/in/onatade-abdulmajeed/

X (Twitter):
https://x.com/spider337761