Introduction
I'm currently in the third week of my #100DaysOfCode challenge, and this week has been different from the previous ones.
When I started this challenge, I had one goal: to become a better software engineer by showing up every day, learning consistently, and building real projects that would prepare me for opportunities.
I spent part of the week applying for jobs but didn't receive any responses. For a moment, I found myself questioning whether all the time and effort I was investing in learning, building, and improving myself would eventually lead to the opportunities I was hoping for.
But after thinking about it, I realized that giving up wouldn't change anything. So I kept building, kept learning, and I will keep on showing up.
Looking back now, I'm beginning to understand that this journey is about more than becoming a better software engineer. It's teaching me patience, resilience, consistency, and the importance of trusting the process, even when the results aren't immediate.
"Make it work, make it right, make it fast."
— Kent Beck
Day 10: Turning My Product Management App into a REST API
I continued working on my Product Management Console App. The project started as a plain Java application, and I decided to convert it into a Maven project to prepare it for development with the traditional Spring Framework.
At this point, the application could already manage products and search for them by name, brand, and type. I then created a PostgreSQL database, designed the product table, and successfully stored my product data using JDBC.
After connecting the application to the database, I exposed its functionality through REST endpoints, making it possible to interact with the application over HTTP instead of running everything directly from the console.
What I Learnt and Explored
- Connecting a Java application to PostgreSQL using JDBC
- Creating and configuring a PostgreSQL database
- Designing a relational database table for products
- Storing application data in a database instead of memory
- Understanding how Java applications communicate with relational databases
Challenges I Faced
One of the biggest adjustments was moving from storing data in memory to persisting it in a real database. This required setting up the database correctly, creating the product table, and ensuring the application could establish a successful connection through JDBC.
Although I had just returned to school and couldn't spend as much time coding as I had planned, I was able to complete the database setup and successfully store product records in PostgreSQL.
Seeing the application save data in a real database instead of memory was a satisfying milestone because it made the project feel much closer to a real-world application.
Application Successfully Connected to PostgreSQL
Day 11: Rebuilding My Product Management App with Spring Boot
On Day 11, I took another big step in my backend journey by rebuilding my Product Management App with Spring Boot.
Instead of continuing with the console-based Java application, I created a new Spring Boot project and began migrating the application's functionality.
What I Learnt and Explored
- Setting up a Spring Boot project
- Connecting Spring Boot to PostgreSQL
- Configuring Spring Data JPA
- Using
JpaRepositoryto retrieve data without writing SQL queries manually - Understanding how Spring Data JPA simplifies database interactions
Challenges I Faced
While testing the application, I ran into a bug that prevented my data from being retrieved correctly.
After checking the issue, I realized my database column was named Id while my entity expected id. Since PostgreSQL is case-sensitive when identifiers are quoted, this mismatch caused the problem.
Renaming the column resolved the issue immediately, and I was able to fetch all product records successfully.
This experience reminded me that sometimes the smallest details can cause the biggest headaches.
By the end of the day, I had successfully transformed the project from a plain Java application using JDBC into a Spring Boot application powered by Spring Data JPA. More importantly, I started to understand not just how Spring Boot works, but why it makes backend development much more efficient.
Day 12: Transforming My Product Management App into a Spring Boot MVC Application
On Day 12, I continued rebuilding my Product Management App by transforming it into a Spring Boot MVC application. This was an important milestone because the application was no longer limited to running from the console—it could now respond to HTTP requests through REST endpoints.
What I Learnt and Explored
- Implementing the Spring Boot MVC architecture using the Controller, Service, and Repository layers
- Connecting the application to PostgreSQL through Spring Data JPA
- Building REST endpoints to retrieve and search products
- Understanding how Spring processes HTTP requests and responses
- Using Lombok to reduce boilerplate code and improve readability
Challenges I Faced
While working on the project, I spent time understanding how Spring Boot processes HTTP requests and responses, how the different layers of the application communicate, and why a Java web application needs a servlet container like Tomcat.
One idea that stayed with me throughout the day was:
"If debugging is removing bugs, then coding is adding bugs."
It reminded me that every line of code is another opportunity for bugs to appear. One thing I've come to appreciate about Spring Boot is how much repetitive code it removes. Less boilerplate means cleaner code, easier maintenance, and fewer places for bugs to hide.
Fortunately, the issues I encountered were relatively small, and I was able to debug and resolve them on my own.
By the end of the day, my Product Management App had evolved from a console-based application into a Spring Boot application exposing RESTful APIs, backed by a cleaner MVC architecture.
Day 13: Starting My Job Posting Application
After completing the core features of my Product Management App by implementing the Update and Delete operations, I decided it was time to start my next project—a Job Posting Application.
The application will use React for the frontend, Spring Boot for the backend, and MongoDB as the database. The idea is to build a platform where companies can post job opportunities and job seekers can browse and search for available positions.
Since I'm more backend-focused, I started with the backend by setting up the Job Posting API. Before writing the application's core features, I focused on preparing the project structure and laying the foundation that I'll continue building on in the coming days.
What I Learnt and Explored
- Completing the Update and Delete operations in my Product Management App
- Creating a new Spring Boot project for the Job Posting API
- Setting up MongoDB Atlas for cloud database management
- Preparing the project structure for future development
- Populating the database with sample job data
Why This Day Was Important
Although I didn't build many features, I spent time preparing the project's foundation. I've learned that starting a project properly choosing the right technologies, organizing the structure, and setting up the database—makes development much smoother later on.
By the end of the day, the project was ready, and I was excited to begin building the API features over the following days.
Day 14: Laying the Foundation for My Job Posting Application
On Day 14, I laid a strong foundation for my Job Posting Application by focusing on the backend. I spent the day setting up the project structure and preparing everything needed for the application.
What I Explored
- Created the application's core layers
- Connected my application to MongoDB Atlas
- Integrated Swagger (OpenAPI) for API documentation and testing
- Built the endpoint to retrieve all job posts
- Configured MongoDB Atlas Search Index in preparation for implementing search
Challenges I Faced
Most of my time was spent troubleshooting.
While integrating Swagger for API documentation, I initially experimented with Spring Boot 4.1.0. However, I later discovered that some of the libraries and examples I was following weren't fully compatible with the newer version.
After investigating the issue, I decided to use this Springdoc OpenAPI dependency:
<dependency>
<groupId>org.springdoc</groupId>
<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
<version>2.8.9</version>
</dependency>
After making that change, the Swagger UI loaded successfully and I was able to continue developing the application.
I also encountered a routing issue while trying to redirect the application's home page to the Swagger UI. Initially, the redirect wasn't working because the routing logic was mixed with my API endpoints.
The fix was to move the routing logic into a dedicated HomeController and annotate it with @Controller instead of @RestController. This allowed Spring MVC to process the redirect correctly and display the Swagger UI as intended.
Although these issues slowed my progress, they helped me better understand dependency compatibility, request mapping, and how Spring MVC handles page navigation. By the end of the day, I had a much stronger understanding of how the framework works behind the scenes.
Application Running Successfully
Day 15: Implementing Search with MongoDB Atlas Search
On Day 15, I continued building the backend for my Job Posting Application by implementing search functionality using MongoDB Atlas Search. This was my first time working with Atlas Search, and it gave me a better understanding of how modern search features are built in NoSQL applications.
What I Learnt and Explored
- Implementing search using MongoDB Atlas Search
- Sorting search results
- Limiting search results for better performance
- Understanding where Client-Side Field Encryption fits into MongoDB applications
- Working with MongoDB aggregation pipelines
Challenges I Faced
Before I could continue implementing the search feature, I discovered that my project had stopped working because of changes I had made while experimenting with different configurations.
Instead of trying to fix everything blindly, I decided to use Git to roll the project back to my last stable commit. This allowed me to compare my changes, identify what had gone wrong, and continue development from a working version.
After restoring the project, I encountered a few integration issues while implementing MongoDB Atlas Search. Most of them were related to configuring the search query correctly and making sure my application communicated properly with MongoDB.
Although I spent more time debugging than expected, the experience reinforced an important lesson: version control isn't just for collaborating with others—it's also one of the best debugging tools a developer can have.
By the end of the day, I had successfully implemented search, sorting, and result limiting, giving my Job Posting Application a much more practical search experience.
Goals for Week 4
As I head into Week 4 of this journey, these are the goals I've set for myself:
- Complete the core features of my Job Posting Application
- Build a fully functional search experience using MongoDB Atlas Search
- Develop the frontend with React and connect it to the backend
- Continue strengthening my understanding of Spring Boot and MongoDB
- Learn more about securing backend applications and API best practices
- Keep documenting my journey and sharing what I learn
Week 3 reminded me that software engineering is just as much about solving problems as it is about writing code. From debugging Spring Boot issues to learning MongoDB Atlas Search and starting a brand-new project, every challenge made me a more confident developer.
I hope the work I'm putting in today eventually leads to the opportunities I'm working so hard for. Until then, I'll keep building, learning, and improving every day.
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
Top comments (0)