This content originally appeared on DEV Community and was authored by Abraham Adedamola Olawale

The Beginning: When Complexity Clouds Your Thoughts

I just began the HNG13 internship in the Backend track, and let me tell you—the first task hit different. The assignment was to build a Dynamic Profile Endpoint that returns user profile information along with a dynamic cat fact fetched from an external API. Simple enough on paper, right?

Wrong. Or at least, that’s what my overthinking brain told me.

The Tech Stack Dilemma

I had options. I code in PHP, Node.js/Express, and Next.js. Standing at this crossroads, I felt a bit sceptical about which path to take. After some deliberation, I chose Node.js/Express because it aligned perfectly with the Backend roadmap I’m following for my personal learning. This way, I could learn and build simultaneously—two birds, one stone.

The Overwhelm Was Real

When I first saw the task description, I’ll be honest—I was quite overwhelmed. You know how people preach about the complexity of HNG? Those thoughts were clouding my judgment. I didn’t know where to start from. The abstraction seemed impenetrable.

But then I remembered something important: “na me go dey overthink” (I’m the one overthinking), and overthinking doesn’t solve problems. Action does.

Breaking Through: Reading, Understanding, and Conquering

So what did I do? I read the task description thoroughly. I mean really thoroughly. After looking beyond the abstraction, I was able to understand the project requirements and come up with an approach.

I realized I needed to use what I call the “Divide and Conquer” strategy—breaking down the huge problem into smaller, manageable parts and tackling them step by step.

My Approach:

1. Understand the fundamentals first

   • What exactly is an API?
   • How does it work?
   • What’s the proper structure of an API response?

2. Break down the task requirements

   • Create a GET endpoint at /me
   • Return JSON with specific fields
   • Integrate with an external Cat Facts API
   • Handle errors gracefully
   • Generate dynamic timestamps

3. Consult documentation

   • I dove into the docs to understand implementation details
   • Learned about error handling patterns
   • Studied HTTP status codes
   • Explored rate limiting concepts

4. Build incrementally

   • Started with a basic endpoint
   • Added external API integration
   • Implemented comprehensive error handling
   • Added rate limiting for production readiness

The Implementation

Here’s what my final implementation looked like:

Key Features I Implemented:

1. Dynamic Timestamp Generation

timestamp: new Date().toISOString()

Every request generates a fresh UTC timestamp in ISO 8601 format.

2. External API Integration
I used Axios to fetch cat facts from https://catfact.ninja/fact with a 5-second timeout to prevent hanging requests.

3. Comprehensive Error Handling
This was the game-changer. I implemented specific error responses for different scenarios:

• 404: When the Cat Facts API returns “not found”
• 500: For server errors from the external API
• Timeout errors: When the API takes too long to respond
• General errors: Fallback for unexpected issues

4. Rate Limiting
I added rate limiting (5 requests per minute) to prevent abuse and ensure fair usage.

The Result

Check out the working endpoint:

• Live URL: https://dynamic-profile-server-4bb72905de93.herokuapp.com/me
• GitHub Repo: https://github.com/Dprof-code/dynamic-profile-server

The API returns a clean JSON response with all required fields:

• Status
• User information (email, name, stack)
• Dynamic timestamp
• Random cat fact

What I Learned

This task taught me invaluable lessons that go beyond coding:

1. Understanding Comes Before Implementation

You can’t solve what you don’t understand. Taking time to read, research, and comprehend the problem is not wasted time—it’s the foundation of your solution.

2. Break It Down

Huge problems are just collections of smaller problems. When you divide and conquer, suddenly that mountain becomes a series of manageable hills.

3. Documentation Is Your Best Friend

I consulted multiple resources:

• Axios Error Handling Documentation
• HTTP Status Codes Reference
• Rate Limiting Concepts
• Express Rate Limit Implementation

4. Overthinking Is the Real Enemy

“na me go dey overthink”—this Nigerian pidgin phrase became my mantra. I was my own biggest obstacle. Once I got out of my own way, the path became clear.

5. Error Handling Matters

Real-world applications need to handle failures gracefully. My implementation considers what happens when external APIs fail, timeout, or return unexpected responses.

Looking Forward

I’m hyperpumped for what’s to come! This first task showed me that I can tackle complex problems when I approach them systematically. The HNG internship is already pushing me to think like a real backend developer—considering edge cases, error scenarios, and production-readiness.

To anyone feeling overwhelmed by their first backend task: you’ve got this. Read thoroughly, break it down, consult the docs, and start building. The complexity is just an illusion created by looking at everything at once.

Tech Stack Used

• Runtime: Node.js
• Framework: Express.js
• HTTP Client: Axios
• Rate Limiting: express-rate-limit
• Hosting: Heroku

Connect With Me

I’m documenting my entire HNG13 journey. Follow along as I continue to learn, build, and grow!

• GitHub: @Dprof-code
• Twitter/X: @pr0devs

Are you also participating in HNG13? How did you approach Stage 0? Drop a comment below—I’d love to hear about your experience!

HNG13 #Backend #NodeJS #APIDesign #WebDevelopment #LearningInPublic

This content originally appeared on DEV Community and was authored by Abraham Adedamola Olawale