Forem: Ukeme Edet

My Journey Building a Dynamic Profile API with FastAPI

Ukeme Edet — Sat, 18 Oct 2025 08:11:00 +0000

I'm excited to share my latest project: a simple but powerful RESTful API that serves up my professional profile and a random cat fact with every request! This task was a great way to practice consuming third-party APIs, handling dynamic data, and structuring a clean JSON response.

The Challenge

The goal was to create a /me endpoint that returns a JSON object containing:

My name, email, and tech stack
The current UTC time in ISO 8601 format
A fresh cat fact from the Cat Facts API (https://catfact.ninja/fact)

My Approach

I chose the Python/FastAPI stack for its speed, simplicity, and modern features. Here’s a breakdown of my process:

Project Setup: I started by setting up a clean project structure with main.py for the application logic, requirements.txt for dependencies, and a README.md for documentation.
FastAPI and Pydantic: I used FastAPI to define the /me endpoint and Pydantic to create models for the response. This ensures the data is always in the correct format.
Fetching Cat Facts: The httpx library made it easy to make an asynchronous request to the Cat Facts API. I also implemented error handling to gracefully manage situations where the external API might be down.
Dynamic Timestamp: I used Python's datetime module to generate the current UTC time for each request, ensuring the timestamp is always up-to-date.
CORS: I enabled CORS (Cross-Origin Resource Sharing) to allow the API to be accessed from any web browser.

What I Learned

API Integration: This project was a great reminder of how to effectively consume external APIs and handle potential failures.
Data Modelling: Pydantic is a powerful tool for data validation and ensuring a consistent API response.
Asynchronous Programming: Using async and await with httpx is a clean and efficient way to handle HTTP requests in FastAPI.
Best Practices: From project structure to error handling, this task reinforced the importance of writing clean, maintainable code.

Check out the running application and the code on my GitHub!

#FastAPI #Python #API #Backend #Developer #HNGInternship #Tech

🌟 Whispers: Where Secrets Find Their Voice

Ukeme Edet — Sun, 15 Sep 2024 22:36:19 +0000

Ever wanted to speak your mind without showing your face? Enter Whispers, the anonymous messaging platform that’s about to shake up the way we communicate!

🤫 Your Digital Confession Booth

Whispers is like having your own inbox for secrets. People can drop messages, but only you hold the key to read them. Perfect for getting raw feedback, whistleblowing, or sharing those thoughts you've been keeping locked away.

💡 Meet the Masterminds Behind the Curtain

Ukeme Edet (Tech Wiz) – The Backend Architect
Eniola Abayomi (Enielect) – The Stylish Frontend Engineer
Bukunmi Ogunneye – The Eccentric UI/UX Designer

Conceived in August, launched in September. One month of non-stop hustle and dedication!

👥 Who’s It For?

Businesses looking for honest, no-nonsense feedback
Schools eager to hear the real student buzz
Anyone with a secret that needs to be shared

🔒 The Secret Sauce

We focused on:

Fort Knox-level security – Your secrets are safer than your most guarded password
Slick, mobile-friendly design – Because secrets don’t wait for desktops
A robust backend to handle a flood of anonymous messages

🚀 My Personal Mission

"Whispers isn't just another project; it's a journey from concept to reality, showing that with persistence, any idea can come to life."

⚔️ The Challenge: My Journey to Whispers

When I saw a friend build an anonymous platform, I couldn’t resist taking on the challenge. "Without a clear starting point, I jumped into the necessary technologies. Showing off Whispers, I've proven that with passion and determination, you can achieve anything."

🏗️ Architecture Diagram

Check out the system that makes the magic happen:

🔧 Technology Stack

Here’s what powers Whispers:

UI Design: Figma for collaborative design
Frontend: Next.js for fast, responsive, and SEO-friendly frontend development
Backend: Flask for building robust APIs
Database: MySQL for data reliability and integrity

🧩 Key Features

Anonymous Inbox Creation
Secure Message Transmission
Responsive Design across devices

🎓 Lessons from the Whisper Chamber

Building Whispers has been an incredible learning experience, pushing me to grow in API development, database management, and server administration. This project confirmed my passion for full-stack development and sparked a deeper interest in security-focused applications.

I’m excited to continue learning more about encryption, advanced database systems, and cloud technologies.

👨‍💻 About the Author

Ukeme Edet is an enthusiastic software engineer, currently studying in the ALX SE program. With experience in frontend development (Angular) and systems programming (C and C++), Ukeme brings a well-rounded skill set to his projects. He’s now focusing on backend development using Flask and FastAPI, always looking to expand his technical capabilities.

🖥️ Explore More:

Project GitHub: Whispers Backend, Whispers Frontend
Live Project: Whispers
Project Landing Page: Whispers
LinkedIn: Ukeme Edet

How I Solved Deployment Challenges: A Guide to Using Gunicorn and Nginx with a Flask Application on Ubuntu

Ukeme Edet — Thu, 27 Jun 2024 20:32:48 +0000

Intro:

Hello guys 👋🏾, coming with another story, today on how I solved deployment issues while deploying a Flask app using gunicorn and Nginx 🙂
So, here I had built the backend for the project, just an API connecting to the frontend client. I had built the API and tested it locally successfully but when it came to deploying on a physical server, the problems came raining down 😮‍💨
Now what's the use of an API if it isn't available for consumption? 🤔
It doesn't serve a use I guess So I had to fix it 🥲

Strategy for Deployment:

Now to understand the problem, we must talk about the strategy for the deployment. The Plan: The Flask app is to be run with the gunicorn HTTP Server(as a service), with this running on the server, we would use Nginx as a reverse proxy to accept HTTP requests and redirect them to the sockets running the app and to send the response to the client. That was the plan.
Now this plan was selected because these choices are popular choices 🫣 and they integrate well with each other, they are easily configured which makes it easier 🙂

The Production Environment:

When it came to setting up the environment, I used an Azure server(running Ubuntu 22.04), Python 3.12, gunicorn 22.0

The Genesis of the Problem:

After cloning the project from GitHub, I tested it locally with the Python runtime and it worked! 🧑🏾‍💻
I tried it with the gunicorn command and it worked too.
I wrote a config file for the service to run the gunicorn server and checked the status of the service and it was up and running perfectly with the socket 🙂

Now was the time for the problematic part, I went on to install the Nginx server which was successful, and then I went into the config to set up the server for the project... I created the config file for the sit which set up the server to redirect the requests to the socket.
I created the symlink to the appropriate folder and tested the config for any issues... Successfully, the check went through 🫠

The Puzzle:

Now I thought that part was done, so I used my domain to make the machine accessible through it.
Now for the test of faith, I entered the API endpoint into my Postman client, and it failed(actually it timed out), I was wondering why that was.
Initially, I realised that the firewall for the server on the Azure dashboard was blocking all HTTP requests so I quickly fixed that... Still no progress 😮‍💨
Then I deep-dived into the NGINX log files where I found that there was an error in the log file.
A summary of the error was a permission issue, I checked the permission of the project folder, the nginx config files, the nginx service and the gunicorn service file, with the help of ChatGPT, I tweaked the permission as advised but still, the same error 😢
I tried many other things over 3 days but all to no avail 😢
As Dan Salomon once said

"Sometimes it pays to stay in bed on Monday, rather than spending the rest of the week debugging Monday's code" - Dan Salomon

The Way Out:

Finally, I checked an appealing YouTube video to alleviate this pain... As I consumed its content, by a stroke of luck, the YouTuber ran into the same issue and gave the fix which I implemented(setting the permission of the home directory to 775 🥲).
I:

Recloned the repo
Rewrote the config for the service(with my_username as the user and www-data as the group)
Reconfigured the Nginx server
Changed the permission on the home directory(to 775) to enable the service access to it
Restarted the services(Nginx and gunicorn) And tested again... IT WORKED!!! 🎉🎉

Conclusion:

Well, after it was deployed, the pain did go away 🥲 In the end, the API was up and functional and I was a happy dev 🙂 This blog was inspired by the HNG 11 Program.

About Me 🫣:

My name is Ukeme Edet, I'm a Software Engineer, but I'm currently exploring Backend Systems. I recently started the HNG Program. I heard it's going to be a very interesting and challenging journey, but I look forward to becoming a Finalist 😊
As a Backend Engineer, I decided to gain real-world experience in the software development lifecycle. Looking ahead, it will be worth it. :)

Singly Linked Lists in C - A Fun and Easy Guide

Ukeme Edet — Fri, 20 Oct 2023 19:13:40 +0000

🚀 What's Ahead

We're diving into singly linked lists in C - no jargon, just plain talk. We'll show you how to create your own list, navigate it, and even kick stuff out. Whether you're a C novice or a pro, we've got your back. Short on attention span? No worries. We're spicing things up with code snippets and diagrams. 📊💡

Who's This For

If you've got C basics down, you're in. Newbie or seasoned coder, we're here for you. Plus, you're in for a treat with loads of code snippets and visuals – because learning tech is way cooler when you see it. 🎉👀

📜 Introduction

Singly Linked Lists Unwrapped

Imagine a linked list as a chain of data. Each link has a piece of info and points to the next one. They're versatile and can power stacks, queues, and graphs. But remember, they're great for some things and not for others. Memory leaks? Yeah, they're a thing. We'll cover the whole story. 🧩🔍

🚀 Why They Matter

Singly linked lists are like the Swiss Army knife of C programming. They're speedy for adding and removing stuff from the start and end. Plus, you can use them for stacks, queues, and more. They're a must-know in the C world. 🌌🛠️

📚 Singly Linked Lists Basics

The Skinny on Singly Linked Lists

Think of them as a chain of nodes. Each node has info and points to the next. The first node is the head, the last is the tail. If the head's empty, so is the list. 🚶‍♂️🔗

Common Operations

Inserting and Deleting 101

Insertion:
- At the Start: Update the head to the new node.
- At the End: Find the tail and link to the new node.
- After a Node: Plug into the middle. 📥📤

Deletion:
- From the Front: Update the head.
- A Specific Node: Jump over it. 🗑️🚪

Traversal:
- Start at the head and follow the chain. 🚶‍♂️🔍

There is more to explore, like searching, reversing, and merging lists. 🌐🕵️

🔗 Singly Linked List in C

Node Structure

A node has two parts: data and the next node's pointer. Simple, right? 🧩🔗

Creating a node? It's a breeze: 🛠️

To link it in, update the previous node's pointer. 🧩🔗

Insertion and Deletion

Adding at the Start: Update the head. 🚀📤

End of the Line: Find the tail and link in. 🛤️🚀

Between the Links: Squeeze in. 📥📤

Deleting the Head: Swap in the next. 🗑️🚪

A Specific Node: Skip over. 🏃‍♂️🚪

Much more to explore, depending on what you need. 🚀🔥

🚶‍♀️ Traversal

To see it all, follow the chain:

Start at the head.
Hop to the next.
Print the data. 🚶‍♂️🔍

🌟 Advantages and Warnings

👍 Pros:

Dynamic: Adjusts as needed.
Swift at Starts and Ends: Change head or tail.
User-Friendly: C programming made simple. 🚀🌟

👎 Cons:

Not for Random Hunting: Search starts from scratch.
No Magic for Middle Goodbyes: You need to find and skip.
Watch for Memory Leaks: Keep it tidy. 💣🔥

🏆 Best Use Cases:

Stacks: Last in, first out.
Queues: First in, first out.
Graphs: Nodes connect like a web. 🗄️📁

🌍 Real-World Scenarios:

Browser History: Your digital path.
Playlist: Your music party.
File System: Your computer's folders and files. 🌐🎵

🧩 Puzzle Pieces: Time and Space

Here's the lowdown on time and space:

Operation	Time	Space
Add at Start	🚀🎈	Efficient
Add at End	Slightly Slower	Efficient
Add After	Slightly Slower	Efficient
Delete from Start	🚀	Efficient
Delete from End	Slightly Slower	Efficient
Delete a Node	Slightly Slower	Efficient
Traversal	Linear Search	Efficient

🛠️ Pro Tips and Tricks

Start with a dummy node for easier handling.
Save past searches for future shortcuts.
Consider double-linked lists if you're heavy on insertions and deletions. 🔗👍

📝 Coding Wisdom

Meaningful names for variables and functions are the way to go.
A touch of comments helps others understand your code.
Thorough testing keeps surprises at bay. 🧪👨‍💻

📚 Bonus Resources

Dig deeper into linked lists: Wikipedia
Level up with doubly linked lists: Doubly Linked Lists
Get in sync with C stacks: Stacks
Master C queues: Queues
Explore C graphs: Graphs

🎉 In a Nutshell

Singly linked lists are your Swiss Army knife for C. They're versatile, but like any tool, they have their quirks. So, learn the ropes and make your code dance. 💃🕺