Self Maintaining API

• 

  This image shows the dashborad of the project

Inspiration

The idea behind Self-Maintaining API was inspired to me by the startup ideas and problem spaces I came across through Y Combinator's Fall 2027 requests.

What it does

This software is an attempt to make API maintenance easier through automation and AI. It detects changes in APIs, identifies which parts of a codebase might be affected, and uses AI to suggest fixes. It then validates those changes before preparing them for review. The idea is to reduce the amount of manual effort developers spend fixing integrations whenever an API changes.

How we built it

I built the project using Python for the core backend and a React-based dashboard for the interface. The system is divided into different stages, from detecting API changes to analysing their impact and generating fixes using an LLM through Nebius Token Factory. I also added a validation process to test proposed changes before applying them, along with a mock API environment to demonstrate how the entire workflow works.

Challenges we ran into

Honestly, getting everything to work together was one of the most challenging parts of this project. There were times when the backend simply refused to cooperate, and even when it was running, the frontend wouldn't properly communicate with or read the data coming from it. Getting the different components to work together took quite a bit of debugging and trial and error. Deployment was another major hurdle, as things that worked perfectly in the local environment didn't always behave the same way once deployed. I spent a good amount of time fixing these issues, figuring out what was going wrong, and getting everything to work as one complete system. It was frustrating at times, but it also ended up being one of the most valuable parts of the experience.

Accomplishments that we're proud of

As for the accomplishments, getting the project to work as a complete system is something I am proud of. I went through quite a few roadblocks, especially with the backend refusing to cooperate, the frontend struggling to communicate with it, and deployment issues that made things even more complicated. There were moments when getting everything to work together felt harder than building the actual features. But after a lot of debugging, experimenting, and going back and forth between different parts of the project, we managed to bring everything together into a working prototype. I am particularly proud that I didn't stop at building individual components but actually got them communicating with each other and presenting the entire workflow through a dashboard. Seeing something that initially felt like a collection of disconnected pieces finally come together was probably the most satisfying part of the experience.

What we learned

This project introduced me to a lot of things I hadn't explored properly before. I got to understand new API concepts and how APIs actually fit into the bigger picture of software development. Working with Nebius Token Factory was also a completely new experience for me. It opened up a different way of thinking about how LLMs can be integrated into actual applications rather than just experimenting with ML models. I also got much more hands-on experience with backend development, frontend integration, and deployment. Looking back at where I was a few months ago.

What's next for Self Maintaining API

For now, the main goal is to make the tool more efficient and capable of handling a larger workload. Since this is currently a demo, the system processes one pull request at a time. I'd like to improve that so it can handle multiple pull requests simultaneously, making the overall process faster and more practical. I think the next step is to take what I've built so far and make it more efficient, scalable, and closer to something developers could actually use in their everyday workflows.

Built With

• nebius
• nvidia
• openapi
• pytest
• python
• react
• render
• typescript
• vite
• yaml