Introduction
Weeks 5 and 6 have been the busiest and most rewarding weeks since I started my #100DaysOfCode challenge.
I couldn't publish my Week 5 recap because I was completely focused on the APIConf × Monnify Hackathon. My teammate and I were trying to get everything done before the submission deadline, spending most of our time building features, fixing bugs, integrating APIs, deploying the application, and preparing our demo. By the time we submitted, there wasn't enough time to sit down and write an article.
Now that the hackathon is over, I want to look back at everything I accomplished over the past two weeks.
During Weeks 5 and 6, I started and completed my first hackathon project, VeriFund, deployed my JobPost application, continued learning Spring by exploring Aspect-Oriented Programming (AOP) , and attended APIConf 2026.
Here's how the last two weeks went.
Day 23: Improving My Job Posting Application
Before the hackathon began, I continued improving my Job Posting Application.
I focused on refining the frontend by improving the overall user interface and spacing, adding a loading spinner for a smoother user experience, and implementing an empty search state to handle cases where no jobs matched a user's search. I also made several smaller UI improvements to make the application feel more polished.
I also deployed the React frontend to Netlify. Although the backend hadn't been deployed yet, it was a big step toward turning the project into a fully functional full-stack application.
Seeing the frontend live motivated me to keep working toward connecting it with the backend, which I completed later during these two weeks.
Day 25: Completing My Job Posting Application
I continued working on my Job Posting Application with the goal of getting it ready for deployment.
One of the biggest improvements was completing the Job Details page, allowing users to view complete information about each job posting. I also added an Apply Now feature that supports both external application links and email addresses, making the application more practical for real-world use.
On the backend, I extended my Spring Boot API by adding an applicationLink field to the JobPost model and updated the React frontend to consume the new data correctly. I also refactored parts of the frontend to pass complete job objects between components instead of individual props, making the codebase cleaner and easier to maintain.
A good part of the day was spent debugging integration issues between the frontend and backend. After fixing request validation problems and testing the complete workflow, I successfully verified that users could create job posts, search for jobs, and view job details seamlessly.
By the end of the day, the application was functioning as a complete full-stack project and was finally ready for deployment.
Demo: https://jobposting-app.netlify.app/
Source Code Frontend: https://github.com/Spider1201/job-post
Day 26: Preparing for My First Hackathon
After wrapping up my Job Posting Application, I shifted my focus to the APIConf Lagos 2026 × Monnify Developer Challenge.
Since it was my first hackathon, I wanted to understand what I was getting myself into before writing any code.
I spent the day reading through the information on the official APIConf website, going through the challenge requirements and judging criteria, joining the hackathon community, and introducing myself to other participants. I also spent some time researching ideas that could solve real problems using Monnify's APIs.
One thing I also did was read a few articles on how to prepare for hackathons. A piece of advice that stayed with me was to build something simple that you can actually finish instead of trying to build everything at once.
I didn't have a final project idea by the end of the day, but I felt much more confident about how I wanted to approach the challenge.
Looking back now, this was the day the journey that eventually became VeriFund started.
Official Event Website: https://apiconf.net/
Day 27: Planning VeriFund
With the research out of the way, it was finally time to start planning our hackathon project.
My teammate and I officially began working on what would later become VeriFund.
We spent time discussing the problem we wanted to solve and how we wanted the application to work. We talked through different ideas before settling on a crowdfunding platform that would make fundraising more transparent through campaign verification.
Most of the day was spent planning the backend. We identified the core features we wanted to build, including user authentication, campaign creation and verification, donations, payment processing with Monnify, and email notifications. We also discussed how the Spring Boot backend would communicate with the Next.js frontend and sketched out the API endpoints we would need.
We spent the entire day planning. No code, just conversations about the product, the features we wanted, and how we would build them.
By the end of the day, we had a solid roadmap and were ready to start building VeriFund.
Day 28: Integrating Monnify into VeriFund
With our project plan in place, I decided to start with the Monnify integration before building the rest of the donation workflow.
I intentionally chose to tackle authentication first because I knew payment gateway integrations usually require a fair amount of setup and debugging. My thinking was simple: if I could get authentication and payment initialization working early, I'd have enough time to resolve any issues before connecting the rest of the application.
That decision turned out to be the right one.
One of the biggest milestones was successfully authenticating with Monnify, implementing payment initialization, and generating my very first checkout URL from the backend. Seeing a real payment gateway respond to my API instead of just returning dummy data was a great feeling.
What I Worked On
- Set up Monnify Sandbox authentication
- Implemented payment initialization in the Spring Boot backend
- Successfully generated my first Monnify checkout URL
- Configured Spring Security for the payment flow
- Tested the payment initialization endpoint using Swagger
Challenges I Faced
The integration definitely wasn't straightforward.
The first issue I ran into was Maven and JDK configuration problems, which prevented the project from building correctly. Once that was fixed, Spring Security kept returning 403 Forbidden responses while I was testing my endpoints.
After resolving that, I discovered that my Monnify requests were still failing because my request payload and configuration weren't right. I spent a lot of time comparing my implementation with the Monnify documentation, checking my environment variables, authentication headers, and API requests until I finally got a successful response.
Getting that first checkout URL felt like a huge win because it meant the backend was finally communicating with Monnify successfully.
By the end of the day, payment initialization was working, and I had a much better understanding of Spring Security, REST API integration, and how payment gateways work behind the scenes.
Day 29: Building Authentication for VeriFund
After getting Monnify integration working, my next focus was authentication.
Since VeriFund would have different types of users, I wanted to build authentication before moving on to campaign management and authorization.
What I Worked On
- Implemented user registration
- Added BCrypt password hashing for secure password storage
- Built JWT authentication from scratch
- Implemented user login with JWT token generation
- Tested registration and login endpoints using Swagger
- Continued improving the backend architecture of VeriFund
Challenges I Faced
Building authentication involved more than just generating a JWT.
I spent a good amount of time configuring Spring Security correctly, making sure requests were authenticated as expected, and verifying that JWTs were being generated and returned after a successful login.
There were a few configuration issues along the way, and I had to repeatedly test my endpoints in Swagger until registration, password hashing, and login all worked together correctly.
By the end of the day, users could register successfully, passwords were securely stored using BCrypt, and a valid JWT was returned after authentication—a major milestone for VeriFund.
Day 30: Completing the Donation Module
The Donation Module was one of the biggest features in VeriFund, and today I finally completed it.
What I Worked On
- Implemented the complete donation workflow
- Restricted donations to approved campaigns only
- Automatically updated each campaign's amount raised after a successful donation
- Generated a unique payment reference for every donation
- Added endpoints to retrieve donations for a campaign
- Added an admin endpoint to retrieve all donations
Challenges I Faced
Most of the donation functionality worked as expected, but I ran into an issue with JWT authentication while testing protected endpoints in Swagger.
Even with a valid token, some endpoints weren't being authorized correctly. After tracing through the security configuration and testing different requests, I was able to identify the problem and update the JWT authentication flow so the protected endpoints worked as expected in Swagger.
With that resolved, I was finally able to test the complete donation workflow from end to end.
Day 31: Deploying VeriFund
After Implementing the core features in place, I decided to put VeriFund online.
What I Worked On
- Deployed the Spring Boot backend to Render
- Connected the application to MongoDB Atlas
- Configured production environment variables
- Tested the live API using Swagger
- Shared the deployed backend with my teammate so frontend integration could begin
Challenges I Faced
Deploying the application wasn't as simple as pushing the code to Render.
I ran into a few issues along the way, including build failures, missing environment variables, and problems connecting to MongoDB Atlas from the deployed application. At one point, the application deployed successfully but still couldn't communicate with the database because of configuration issues.
I spent a good amount of time checking deployment logs, verifying my environment variables, and updating the MongoDB network settings until everything finally worked.
Seeing the API come online and successfully respond to requests from the deployed environment made all the debugging worth it. It was my first time deploying a backend for a hackathon project, and it gave me a much better understanding of what it takes to move an application from local development to production.
Live API: https://verifund-mmwl.onrender.com/swagger-ui/index.html
Day 32: Frontend Integration and Deployment Fixes
With the backend deployed, the next step was making sure everything worked together.
My teammate and I spent the day connecting the frontend to the live backend and fixing the issues that came up during integration. Most of the work wasn't about building new features, it was about making the existing ones work reliably in a deployed environment.
What I Worked On
- Updated and redeployed the Spring Boot backend after fixing integration issues
- Configured CORS to allow communication between the frontend and backend
- Worked with my teammate to connect the frontend to the live APIs
- Fixed the Monnify payment verification flow
- Resolved authentication and API access issues
- Completed the backend README documentation
- Tested the application with my teammate to make sure the core features worked as expected
Challenges I Faced
Once the frontend started communicating with the deployed backend, a few issues that didn't appear during local development started showing up.
I had to update my backend configuration, redeploy the application a couple of times, and troubleshoot CORS, authentication, and payment verification until everything worked correctly.
By the end of the day, the frontend and backend were communicating successfully, and VeriFund felt much closer to being ready for the hackathon submission.
Day 33: Submitting VeriFund
Submission day had finally arrived.
Before submitting the project, I spent some time making sure everything was ready.
What I Worked On
- Finalized the backend API documentation
- Recorded the project demo
- Reviewed the deployed application one final time
- Completed the hackathon submission form
- Submitted VeriFund for the APIConf × Monnify Hackathon
Challenges I Faced
The biggest challenge on submission day was recording the demo video.
Our original plan was to demonstrate the application through the frontend, but we ran into frontend issues close to the submission deadline. Instead of spending more time trying to fix everything, I decided to record the demo using the backend APIs in Swagger so we could still showcase the core functionality of VeriFund.
Preparing the demo, making last-minute checks, and recording everything took longer than we expected, and because of that, we ended up submitting our project later than we had planned.
Even though things didn't go exactly as we hoped, we still managed to submit a working project.
Live Demo: https://verifund-f.vercel.app/
Day 34: Shipping My JobPost Application
After submitting VeriFund for the hackathon, I decided to return to one of my personal projects and finally ship it.
I had been working on my JobPost application for a while, and this felt like the perfect time to deploy it and make it accessible online.
What I Worked On
- Deployed the Spring Boot backend to Render
- Connected the backend to MongoDB Atlas
- Deployed the React frontend
- Configured CORS for seamless frontend-backend communication
- Added Docker support
- Wrote professional README files for both the frontend and backend repositories
Challenges I Faced
Deploying the application wasn't completely straightforward.
I had to configure production environment variables, update my MongoDB Atlas settings, and fix CORS issues before the frontend could communicate with the deployed backend successfully. I also Dockerized the backend to make it easier to run and deploy consistently.
By the end of the day, the application was fully deployed and available online. It felt good to finally ship another project after spending the previous week focused on the hackathon.
Live Demo: https://jobposting-app.netlify.app/
Backend API: https://job-post-api.onrender.com/swagger-ui/index.html
Day 35: Learning Spring AOP
After spending the past few days building and deploying projects, I decided to slow down and focus on learning something.
Today's focus was Spring AOP (Aspect-Oriented Programming).
I wanted to understand how Spring keeps business logic clean by separating concerns like logging, security, validation, and exception handling instead of scattering the same code throughout an application.
What I Learned
- What Aspect-Oriented Programming (AOP) is
- Cross-cutting concerns
- Aspects
- Advice and the different annotations:
@Before@After@AfterReturning@AfterThrowing@Around
My Thoughts
One thing I enjoyed while learning AOP was realizing that many of the features I've already used in Spring Boot are powered by concepts like this behind the scenes.
The more I understand how Spring works internally, the more comfortable I become using it. Instead of just knowing what Spring does, I'm starting to understand how it does it, and that makes learning the framework much more interesting.
The next step is to stop reading and start writing my own aspects so I can see these concepts in action.
Day 36: Attending APIConf 2026
After weeks of building, debugging, deploying, and submitting VeriFund, it was finally time for APIConf 2026.
This was my first time attending a tech conference, and I genuinely enjoyed the experience. The event was well organized, and it was exciting to be surrounded by developers and engineers.
One of my favorite sessions was "Software Is Going Headless: What the API Becomes When Agents Run Everything" by Joel Olawanle. One statement that really stayed with me was the idea that APIs are no longer just a feature they're becoming the product itself. That completely changed the way I think about backend development and API design.
I also attended sessions on AI, agent-ready APIs, and Kubernetes, including:
- Software Is Going Headless: What the API Becomes When Agents Run Everything — Joel Olawanle
- AI Can Write Code. But It Doesn't Know Your System — Chigozie Madubuko
- Are Your APIs Ready for Agents? — Auwal MS
- What API Designers Can Learn from the Kubernetes API — Somtochi Onyekwere
Listening to these talks made me realize that while AI can generate code, understanding systems, APIs, architecture, and how everything works together is what makes someone a good software engineer.
Last night, the hackathon results were finally released.
Out of 105 project submissions, only 72 projects were ranked, and VeriFund finished 22nd.
Honestly, I was really happy with that result.
Looking back, I know our project wasn't complete. We still had features we wanted to implement, like the disbursement workflow, and we also ran into frontend issues before submission, which meant I had to record the demo using Swagger instead of the frontend we originally planned to showcase. On top of that, I was balancing school while preparing for my first hackathon, so time wasn't exactly on our side.
Even with those challenges, finishing 22nd gave me a lot of confidence. It showed me that our idea had potential and that the work we put into building the backend was recognized.
More importantly, it taught me an important lesson: it's better to have a few features working perfectly than many features that are only partially complete. That's something I'll definitely carry into my next hackathon.
APIConf also introduced me to technologies and ideas I want to explore further. One of my goals after the conference is to spend more time learning Python alongside my backend journey.
One thing I wish I had done better was networking. I was only able to interact with one person during the event. Next time, I want to meet more developers, have more conversations, and build stronger connections within the tech community.
Looking back, attending APIConf made me feel like a real developer.
Sitting in the same room with experienced engineers, One of the special guests at the event had 24 years of experience, it made me realize how much there is still to learn. It motivated me, and made me feel like I'm finally on the path I've always wanted to be on.
I'm already looking forward to attending APIConf again, participating in another hackathon, meeting more people, and coming back with an even better project.
Images:
Goals for Week 7
With the hackathon behind me, it's time to balance learning with preparing for my upcoming exams.
Here are my goals for Week 7:
- Start preparing for my exams while maintaining consistency with #100DaysOfCode
- Continue learning Spring AOP by building practical examples
- Explore more advanced Spring Boot concepts
- Begin learning Python alongside my Java backend journey
- Improve my existing projects whenever I have the time
- Keep documenting my progress and sharing what I learn
The past two weeks were some of the busiest of my journey so far. I built VeriFund for my first hackathon, deployed multiple applications, attended my first tech conference, and learned a lot about building, deploying, and presenting real-world software. Those experiences pushed me outside my comfort zone and gave me a clearer picture of the kind of engineer I want to become.
For now, my priority is preparing for my exams while continuing to learn consistently. Progress may be a little slower, but I don't intend to stop showing up 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)