DEV Community: Muhammad Ibrahim Hashmi

What Fast API Is Teaching Me About Building AI Beyond the Model

Muhammad Ibrahim Hashmi — Sun, 06 Sep 2026 04:38:32 +0000

When I first started learning AI, most of my attention naturally went to the model itself.

I used to think mainly about questions like:

Which algorithm should I use?
How do I improve accuracy?
How do I preprocess the data?
How well does the model predict?

Those questions still matter.

But over time, as I started building more complete applications, I realized something important:

A good model is only one part of a useful AI system.

Recently, I worked through three FastAPI modules:

CORS
SQL (Relational) Databases
Bigger Applications

At first, these topics may look more like backend engineering than AI.

But that is exactly the point.

The model is not the whole product

A machine learning model in a notebook is not the same thing as a real system.

Once you want real users, APIs, storage, structure, and integration, the problem changes.

Instead of only thinking about predictions, you start thinking about:

how data enters the system
how the frontend talks to the backend
where application data is stored
how the backend is organized
how the project remains maintainable as it grows

That is where FastAPI has started becoming very meaningful for me.

What CORS taught me

CORS may seem like a small technical detail, but it represents a real production issue.

A frontend and backend often run on different origins, and the browser enforces rules around how they communicate.

That means a working model alone is not enough.
The surrounding system also has to be configured properly.

This taught me that deployment and integration matter just as much as model logic.

What SQL databases changed for me

Relational databases were another important step.

In simple demos, it is easy to ignore persistence.

But real applications need to store things such as:

users
requests
results
metadata
application state
logs or records

Working with SQL in FastAPI made me think more seriously about how AI applications behave as actual software systems.

A model may produce intelligence, but the application still needs proper data management.

Why bigger applications matter

The “Bigger Applications” module was especially useful because it focused on structure.

Small apps can survive in one file.

Larger ones should not.

As a project grows, clean separation becomes more important:

routers
dependencies
modules
reusable components
maintainable organization

This is one of the clearest reminders that AI engineering is not only about models.
It is also about building software that remains understandable and usable over time.

How my mindset is changing

I still care deeply about Machine Learning and Computer Vision.

That remains the center of my direction.

But I increasingly want to think beyond:

dataset → model → accuracy

and more in terms of:

problem → data → model → API → database → application → real use

That broader view feels much closer to the kind of engineer I want to become.

Not someone who can only train a model.

But someone who can help turn AI into a complete and usable system.

Final thought

I’m still learning, and I’m still early in the process.

But this shift in thinking already feels important.

FastAPI is helping me understand that building AI in the real world means combining:

machine learning
backend engineering
APIs
databases
structure
integration
maintainability

And honestly, that makes the work even more interesting.

From AI Models to Real AI Systems: What I’m Learning as a Final-Year AI Student

Muhammad Ibrahim Hashmi — Sat, 05 Sep 2026 14:16:03 +0000

Hi DEV 👋

I’m Muhammad Ibrahim Hashmi, a final-year BS Artificial Intelligence student from Islamabad, Pakistan.

Most of my work so far has been around Machine Learning, Computer Vision, Python, FastAPI, and building AI applications end to end.

I joined DEV because I want to document something I’ve been realizing more and more:

Training a model is only one small part of building a useful AI system.

Moving beyond the model

When I first started working with AI, most of my attention naturally went toward things like:

model selection
training
accuracy
computer vision pipelines
predictions

But as I started building complete applications, the questions changed.

How does the model receive data?

How do you expose inference through an API?

What happens when the input is invalid?

How do you connect the model to a frontend?

How do you make the system reliable enough for someone other than you to use?

That is where tools like FastAPI, REST APIs, testing, deployment, and software-engineering practices started becoming much more important to me.

Some things I’ve been building

A few projects that shaped this thinking:

UniTime-AI

An AI-assisted university timetable application where machine learning is part of a larger product workflow rather than the entire product.

Building it forced me to think about how AI decisions fit inside an application and how software architecture affects the usefulness of the model.

Pakistani Currency Assistant

A computer-vision application for recognizing Pakistani currency.

One of the most useful lessons from this project came from failure cases.

A model can produce a confident prediction and still be completely wrong.

That sounds obvious, but seeing a real false-positive case changes how you think about production AI.

A confidence score is not the same thing as reliability.

It made me think much more seriously about:

out-of-distribution inputs
false positives
confidence thresholds
validation
testing with unexpected inputs
safety gates around model predictions

AI Resume Studio

A Python and Streamlit application for creating and analyzing resumes, including ATS-style analysis and resume-to-job-description matching.

This project pushed me toward thinking about AI as part of a workflow instead of as an isolated prediction.

The useful question becomes:

What decision or task is this AI actually helping someone complete?

What I’m focusing on now

Right now I’m especially interested in the engineering side of AI:

Computer Vision
Python
FastAPI
REST API design
model integration
reliable inference pipelines
deployment
testing
building AI systems that solve complete problems

I’m also working on Pur-Aman Pakistan, my final-year project exploring multimodal AI for public-safety incident reporting.

Why I’m writing here

I don’t want this profile to become a collection of AI-generated tutorials or posts about technologies I haven’t actually used.

My plan is simpler:

Build → encounter a real problem → understand it → write about what I learned.

So future posts will probably cover things like:

mistakes I make while building AI systems
Computer Vision failure cases
FastAPI and ML integration
turning ML experiments into usable applications
lessons from real project architecture
reliability problems that accuracy metrics don't reveal

I’m still early in my career, which is exactly why I think documenting the process will be useful.

There will be things I get wrong.

There will be things I understand differently six months from now.

That is part of the point.

If you work in AI, ML, Computer Vision, Python, or production AI systems, I’d be happy to connect and learn from your experience.

Thanks for reading my first post on DEV. 🚀