This is a submission for the GitHub Finish-Up-A-Thon Challenge
What I Built
LinkIt is a bookmark management platform that allows users to save, organise, and manage useful links in one place.
I originally started LinkIt while learning backend development with FastAPI and PostgreSQL. The goal was simple: create a platform where users could store links to articles, tutorials, documentation, and other useful resources without losing track of them.
The project started well, but like many side projects, it eventually got abandoned. The backend was partially functional, authentication existed, and users could save links, but there were still missing features, configuration issues, and unfinished ideas that prevented it from becoming a complete product.
When I saw the GitHub Finish-Up-A-Thon Challenge, I decided it was the perfect opportunity to revisit LinkIt and finally finish what I started.
Technologies Used
FastAPI
PostgreSQL
SQLAlchemy
JWT Authentication
Pytest
GitHub Copilot
GitHub Repository: github.com/akeemomosanya/Linkit
Demo
Live demo: link-it.vercel.app
Video demo:
The walkthrough shows the final product experience: the home page, authentication, and the links dashboard Linkit's core value of saving, organising, and retrieving any link instantly, all in one clean and minimal interface.
The Comeback Story
Where It Started
The original version of Linkit had a partially working foundation,it was far from complete. The project already included:
A FastAPI backend
SQLAlchemy models
Basic user authentication
Link storage functionality
However, several critical bugs prevented it from being production-ready:
Wrong ORM relationship references that caused runtime crashes
A broken login endpoint mixing two incompatible request formats
A shadowed function name that made link creation fail silently
Missing return statements and unhandled database errors
No frontend, no deployment, and no search functionality
One of the first issues I encountered after reopening the project was that the backend would not even start correctly, a reminder of how quickly side projects can become difficult to revisit after months of inactivity.
What Changed
To bring linkit back to life, I focused on fixing the broken core and building everything that was missing.
- Fixed the Backend The first step was getting the application running reliably. I corrected the SQLAlchemy relationships, fixed the authentication flow, resolved import conflicts, and added proper error handling throughout.
- Added Search, Edit, Copy & Delete The original project only had a broken create endpoint. I built out the full link management experience, users can now search by name, edit any field, copy a URL to clipboard instantly, and delete links they no longer need.
- Built the Frontend from Scratch The original project had no UI at all. I designed and built a full three page frontend, a landing page, an auth page, and a links dashboard with a modern dark aesthetic, gradient card banners, and smooth interactions.
- Deployed End to End A project isn't finished until people can actually use it. I deployed the FastAPI backend on Render and the frontend on vercel, with CORS configured and the server kept alive so it's always ready.
Lessons Learned
Reviving an old project was very different from starting a new one. The biggest challenge wasn't writing new features, it was understanding old decisions, untangling accumulated bugs, and building on a foundation that wasn't quite as solid as it looked.
Most importantly, it showed that unfinished projects don't have to stay unfinished. Sometimes they just need a fresh perspective and a little persistence.
My Experience with GitHub Copilot
I want to be honest about this because the experience was genuinely useful in ways I didn't expect going in.
The most valuable thing Copilot did at the start was the code audit. I shared the original code and asked it to identify what was broken. The list it produced was long and accurate, wrong ORM relationship references, a broken login endpoint that mixed two incompatible request formats simultaneously, a shadowed function name that made link creation silently fail, missing return statements, unhandled database errors, and a user.id attribute access on a dict. Some of these I suspected; others I had completely missed. Having that comprehensive list upfront let me fix everything systematically rather than discovering bugs one by one while testing.
The debugging sessions were the second genuinely valuable part. When the deployed frontend kept returning "Failed to fetch," Copilot helped me trace it from a vague network error all the way to the specific cause, the allow_origins list in the CORS middleware was missing the actual vercel URL. When the JWT library kept throwing ValueError: Invalid key, Copilot walked through the different JWT libraries with me (authlib, joserfc, PyJWT) until we landed on the one that worked cleanly with Python 3.14.
For implementation, we mostly pair-programmed. I made the architecture decisions, the endpoint structure, the authentication flow, the ownership scoping on all link queries. Copilot drafted the boilerplate: the Pydantic schemas, the dependency injection patterns, the search and copy endpoints. For the frontend, I described the design direction and Copilot generated the HTML, CSS, and JavaScript structure which I then reviewed and adjusted.
Overall, Copilot shortened the time from "something is broken" to "fixed and understood" significantly especially for debugging, and catching bugs I had stopped seeing. But the judgment calls about what to build, how to structure it, and what actually mattered still came from me. That felt like the right balance.
Top comments (0)