Introduction

After two busy weeks of building VeriFund, deploying projects, participating in my first hackathon, and attending APIConf 2026, this week was much quieter.

Instead of building a new project, I decided to go back to the fundamentals. I spent most of the week learning more about the Spring Framework, especially concepts like Spring AOP, Dependency Injection, the IoC Container, Spring Security, logging, and software design principles.

I also started preparing for my upcoming exams while staying consistent with my #100DaysOfCode challenge. Alongside that, I updated my CV, continued applying for backend roles, and even tried an AI-powered mock interview. Let's just say it was a reminder that I still have a lot to improve when it comes to technical interviews.

Although I didn't ship a new project this week, I don't see it as a slow week. Understanding the concepts behind the framework I use every day is just as important as writing code. The better I understand how Spring works, the better I'll be able to build secure, scalable, and maintainable applications.

"The more I learn, the more I realize how much I don't know."

— Albert Einstein

Day 38: Exploring Core Spring Concepts

With my exams approaching, I shifted my focus from building projects to strengthening my understanding of the Spring Framework. I revised core concepts such as POJOs, Dependency Injection, Programming to Interfaces, Spring AOP, the major Spring modules, and some of the improvements introduced in Spring 5, including WebFlux. It reminded me that understanding the ideas behind the framework is just as important as knowing how to use it.

Day 39: Learning Logging in Spring Boot

As I continued strengthening my understanding of the Spring Framework, I spent the day learning how logging works in Spring Boot.

What I Learned

What a Logger is and why it's important
Using LoggerFactory to create loggers
Logging application events instead of relying on System.out.println()
Why logging is essential for debugging, monitoring, and maintaining applications

Most of my time was spent reading my Spring notes and understanding how Spring Boot handles logging behind the scenes. Although I didn't build anything new, I gained a much better appreciation for why proper logging is considered a best practice in production applications.

Challenges I Faced

There weren't any major technical challenges today.

Day 40: Exploring Spring Security and Software Design Principles

I continued learning the concepts that make Spring Boot applications more secure, maintainable, and scalable.

What I Learned

Different types of AOP advice:
- @AfterReturning
- @AfterThrowing
- @After (Finally)
An introduction to Spring Security
Authentication vs Authorization
Password hashing with BCrypt
An overview of OAuth2
The Gang of Four (GoF) Design Patterns
Dependency Injection
The SOLID Principles

Most of the day was spent studying these concepts and putting some of them into practice with small code examples. Writing code alongside the theory helped me understand how concepts like AOP advice, Spring Security, and Dependency Injection are actually applied in Spring Boot applications. It reinforced the idea that understanding the principles behind the framework makes it much easier to build secure, maintainable, and scalable applications.

Challenges I Faced

The biggest challenge today was understanding how all these concepts relate to one another. Topics like Spring Security, OAuth2, GoF Design Patterns, and the SOLID Principles are broad on their own, and it took time to connect the theory with the small examples I was writing. Even though I was able to practice some of them in code, I know there's still a lot more to explore before I can confidently apply them in larger real-world projects.

Day 41: Understanding Dependency Injection in Spring

I continued learning about Dependency Injection in Spring and gained a better understanding of how the framework manages objects behind the scenes.

What I Learned

Constructor-based Dependency Injection
Setter-based Dependency Injection
Advantages and disadvantages of each approach
Best practices for constructor and setter injection
A high-level overview of the Spring IoC Container
Different ways to configure Spring applications:
- Java-based configuration
- Annotation-based configuration
- XML-based configuration

This was another theory-focused day. I spent time understanding the different approaches to Dependency Injection and why constructor injection is generally preferred in modern Spring applications. Learning how the IoC container creates and manages beans gave me a much clearer picture of what happens behind the scenes whenever I use Spring.

Challenges I Faced

The biggest challenge today was comparing the different configuration approaches and understanding when each one is appropriate. Although annotation-based configuration is the most common today, learning about Java-based and XML-based configuration helped me appreciate how Spring has evolved over time.

Day 42: Learning Spring Annotations and Preparing for Opportunities

Today was a mix of learning and career growth.

What I Worked On

Updated and improved my CV
Followed up on a previous job application
Continued learning Dependency Injection in Spring
Explored Annotation-based Configuration in more depth
Learned how annotations such as:
- @Component
- @Service
- @Repository
- @Controller
- @Autowired
- @Qualifier help Spring create, manage, and inject beans automatically

I also spent time understanding the role each stereotype annotation plays within a Spring Boot application. Before now, I had been using many of these annotations without fully understanding why they existed or what happened behind the scenes. Learning how Spring scans classes, creates beans, and injects dependencies gave me a much clearer picture of how the framework works internally.

Outside of studying, I updated my CV to better reflect the projects and experience I've gained over the past few weeks and followed up on one of my job applications. As much as I'm focused on learning, I'm also actively preparing myself for backend engineering opportunities.

Challenges I Faced

There weren't any major technical challenges today, but understanding how all the different annotations work together required careful reading and experimentation. It was easy to memorize what each annotation does, but my goal was to understand when and why each one should be used in a real Spring Boot application.

Day 43: Practicing Spring Security

After spending the previous few days learning the theory behind Spring Security and Dependency Injection, I decided it was time to put those concepts into practice.

Rather than just reading, I followed a Spring Security tutorial and built the application alongside the instructor. As I worked through it, I adapted it to the newer Spring Security approach, replacing some of the older implementation with the modern configuration style.

What I Worked On

Built a Spring Security application by following a hands-on tutorial
Learned how UserDetailsService is used to load users during authentication
Explored how Spring Security performs in-memory authentication
Practiced using @Autowired with:
- Field Injection
- Setter Injection
Understood how Spring automatically injects dependencies into managed beans
Updated parts of the tutorial code to use the newer Spring Security configuration instead of the older approach

Writing the code myself made a huge difference. Reading about Spring Security helped me understand the concepts, but actually implementing them showed me how all the pieces fit together during the authentication process.

Challenges I Faced

The biggest challenge was understanding the differences between the instructor's implementation and the newer version of Spring Security. Some parts of the tutorial had changed because newer versions of Spring recommend different approaches. Instead of following the old code exactly, I spent time understanding the changes and updating the implementation to match the current best practices.

I wasn't able to complete the database integration for custom authentication yet, but I now have a much clearer understanding of how Spring Security authenticates users before connecting it to a real database. That will be my next step.

Goals for Week 8

With my exams almost behind me, it's time to shift my focus back to building, improving my technical skills, and preparing for backend engineering opportunities.

Here are my goals for Week 8:

Practice LeetCode consistently to strengthen my problem-solving skills
Take more mock technical interviews to improve my interview confidence
Continue applying for backend engineering roles
Continue learning Spring Security and complete database-backed authentication
Build practical examples using the Spring concepts I've been studying
Review core Data Structures and Algorithms for coding interviews
Resume learning Python alongside my Java backend journey
Continue improving my existing projects whenever I have the time
Stay consistent with #100DaysOfCode and keep documenting what I learn

Week 7 reminded me that progress isn't always measured by the number of features you build or projects you deploy. Sometimes, the biggest growth comes from slowing down, revisiting the fundamentals, and understanding how the technologies you use actually work.

From Spring AOP and Dependency Injection to Spring Security, logging, and software design principles, this week helped me build a stronger foundation that I'll carry into future projects.

As my exams come to an end, I'm excited to get back to building while also preparing myself for technical interviews. My goal is not just to become a better backend engineer, but also to become more confident in solving problems, writing clean code, and communicating my thought process during interviews.

If you're also learning, building, or growing in tech, I'd love to connect and follow your journey too.

Let's keep building. 💙

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

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

StackFeed

Week 7 of #100DaysOfCode: Back to the Fundamentals