This is the github starter for the project based FastAPI course tutorial
https://github.com/epythonlab2/ai-document-api

While moving from other web frameworks to 𝐅𝐚𝐬𝐭𝐀𝐏𝐈, one question came to my mind:



𝐖𝐡𝐲 𝐝𝐨 𝐈 𝐧𝐞𝐞𝐝 𝐀𝐏𝐈𝐑𝐨𝐮𝐭𝐞𝐫 𝐰𝐡𝐞𝐧 𝐅𝐚𝐬𝐭𝐀𝐏𝐈 𝐚𝐥𝐫𝐞𝐚𝐝𝐲 𝐥𝐞𝐭𝐬 𝐦𝐞 𝐝𝐞𝐟𝐢𝐧𝐞 𝐫𝐨𝐮𝐭𝐞𝐬 𝐝𝐢𝐫𝐞𝐜𝐭𝐥𝐲?



For a small project, this is enough:



@𝒂𝒑𝒑.𝒈𝒆𝒕("/𝒅𝒐𝒄𝒖𝒎𝒆𝒏𝒕𝒔")

𝒂𝒔𝒚𝒏𝒄 𝒅𝒆𝒇 𝒈𝒆𝒕_𝒅𝒐𝒄𝒖𝒎𝒆𝒏𝒕𝒔():

...

So why introduce APIRouter?



The answer became clearer when I started thinking about a real application.



As the project grows, I may have authentication, users, documents, search, AI processing, and many more endpoints.



Keeping all of these routes in one place can quickly become difficult to maintain.

That’s where APIRouter becomes useful.



It allows me to organize routes by feature and keep the application structure clean.



So my takeaway is simple:



𝐅𝐚𝐬𝐭𝐀𝐏𝐈 𝐥𝐞𝐭𝐬 𝐦𝐞 𝐝𝐞𝐟𝐢𝐧𝐞 𝐭𝐡𝐞 𝐫𝐨𝐮𝐭𝐞𝐬.

𝐀𝐏𝐈𝐑𝐨𝐮𝐭𝐞𝐫 𝐡𝐞𝐥𝐩𝐬 𝐦𝐞 𝐨𝐫𝐠𝐚𝐧𝐢𝐳𝐞 𝐭𝐡𝐞𝐦.



It’s not required to make FastAPI work. It becomes useful when I want the application to stay organized and maintainable as it grows.



This was one of those small FastAPI concepts that made much more sense once I started looking at the bigger picture.



𝐇𝐚𝐯𝐞 𝐲𝐨𝐮 𝐡𝐚𝐝 𝐭𝐡𝐞 𝐬𝐚𝐦𝐞 𝐪𝐮𝐞𝐬𝐭𝐢𝐨𝐧 𝐰𝐡𝐞𝐧 𝐦𝐨𝐯𝐢𝐧𝐠 𝐭𝐨 𝐅𝐚𝐬𝐭𝐀𝐏𝐈?



🔗 𝐆𝐢𝐭𝐇𝐮𝐛: https://github.com/epythonlab2/ai-document-api



🎥 𝐅𝐚𝐬𝐭𝐀𝐏𝐈 𝐜𝐨𝐮𝐫𝐬𝐞: https://www.youtube.com/watch?v=0SLLG2Z_Htw&list=PLQNCas8_eikM



#FastAPI #Python #APIRouter #BackendDevelopment #SoftwareArchitecture #APIDevelopment #PythonDeveloper

The FastAPI Course Github (AI Document API) Project is just updated
Add database connection setup and document model definition
- Implement database connection using SQLAlchemy and environment variables
- Create Document model with fields for title, description, category, and priority
- Update .gitignore to include .env file
- Add required dependencies in pyproject.toml and uv.lock


🔗 𝐆𝐢𝐭𝐇𝐮𝐛: https://github.com/epythonlab2/ai-document-api

🎥 𝐅𝐚𝐬𝐭𝐀𝐏𝐈 𝐜𝐨𝐮𝐫𝐬𝐞: https://www.youtube.com/watch?v=0SLLG2Z_Htw&list=PLQNCas8_eikM

✅ FastAPI Episode 9: Database Setup with PostgreSQL & SQLAlchemy
https://youtu.be/4d4Gs2Y7Fic

While learning FastAPI, I came across another question: 𝐖𝐡𝐲 𝐝𝐨 𝐈 𝐧𝐞𝐞𝐝 𝐏𝐲𝐝𝐚𝐧𝐭𝐢𝐜 𝐰𝐡𝐞𝐧 𝐏𝐲𝐭𝐡𝐨𝐧 𝐚𝐥𝐫𝐞𝐚𝐝𝐲 𝐡𝐚𝐬 𝐭𝐲𝐩𝐞 𝐡𝐢𝐧𝐭𝐬?

For example, I can write:

𝑑𝑒𝑓 𝑐𝑟𝑒𝑎𝑡𝑒_𝑢𝑠𝑒𝑟(𝑛𝑎𝑚𝑒: 𝑠𝑡𝑟, 𝑎𝑔𝑒: 𝑖𝑛𝑡):
...

Python already tells me that name should be a string and age should be an integer.

So what does 𝐏𝐲𝐝𝐚𝐧𝐭𝐢c add?

The difference became clear when working with API request data.
An API receives data from outside the application, and I need more than just type hints. I need to validate that the data has the expected structure and values.

That’s where Pydantic becomes useful.

With FastAPI, I can define a model:

𝑐𝑙𝑎𝑠𝑠 𝑈𝑠𝑒𝑟𝐶𝑟𝑒𝑎𝑡𝑒(𝐵𝑎𝑠𝑒𝑀𝑜𝑑𝑒𝑙):

𝑛𝑎𝑚𝑒: 𝑠𝑡𝑟 𝑎𝑔𝑒: 𝑖𝑛𝑡

FastAPI can then use that model to validate incoming request data automatically.

So my takeaway is:

𝐏𝐲𝐭𝐡𝐨𝐧 𝐭𝐲𝐩𝐞 𝐡𝐢𝐧𝐭𝐬 𝐝𝐞𝐬𝐜𝐫𝐢𝐛𝐞 𝐰𝐡𝐚𝐭 𝐈 𝐞𝐱𝐩𝐞𝐜𝐭.

𝐏𝐲𝐝𝐚𝐧𝐭𝐢𝐜 𝐡𝐞𝐥𝐩𝐬 𝐯𝐚𝐥𝐢𝐝𝐚𝐭𝐞 𝐰𝐡𝐚𝐭 𝐈 𝐚𝐜𝐭𝐮𝐚𝐥𝐥𝐲 𝐫𝐞𝐜𝐞𝐢𝐯𝐞.

This is another small concept that became much clearer once I started building a real FastAPI application.

𝐖𝐡𝐚𝐭 𝐰𝐚𝐬 𝐲𝐨𝐮𝐫 𝐟𝐢𝐫𝐬𝐭 𝐢𝐦𝐩𝐫𝐞𝐬𝐬𝐢𝐨𝐧 𝐨𝐟 𝐏𝐲𝐝𝐚𝐧𝐭𝐢𝐜 𝐰𝐡𝐞𝐧 𝐲𝐨𝐮 𝐬𝐭𝐚𝐫𝐭𝐞𝐝 𝐮𝐬𝐢𝐧𝐠 𝐅𝐚𝐬𝐭𝐀𝐏𝐈?

🔗 𝐆𝐢𝐭𝐇𝐮𝐛: https://github.com/epythonlab2/ai-document-api

🎥 𝐅𝐚𝐬𝐭𝐀𝐏𝐈 𝐜𝐨𝐮𝐫𝐬𝐞: https://www.youtube.com/watch?v=0SLLG2Z_Htw&list=PLQNCas8_eikM

FastAPI Fundamentals Course Tutorial Episode 10: Insert/Create Data into PostgreSQL Database
https://youtu.be/w3EUk1MuJfE

As I build my 𝐀𝐈 𝐃𝐨𝐜𝐮𝐦𝐞𝐧𝐭 𝐀𝐏𝐈 𝐰𝐢𝐭𝐡 𝐅𝐚𝐬𝐭𝐀𝐏𝐈, I’m realizing that building an API is about much more than writing endpoints.


Getting an endpoint to work is just the beginning. A real application needs a solid structure and several pieces working together.

That means thinking about:

- Validating incoming data

- Organizing routes and business logic

- Connecting to a database

- Handling errors properly

- Implementing authentication and permissions

- Testing and deploying the application


Each step introduces a new challenge and a new concept to learn.

That’s why I’m building this project step by step as part of my 𝐅𝐚𝐬𝐭𝐀𝐏𝐈 𝐬𝐞𝐫𝐢𝐞𝐬. My goal is to go beyond isolated examples and demonstrate how these concepts come together in a practical AI application.


𝐁𝐞𝐜𝐚𝐮𝐬𝐞 𝐥𝐞𝐚𝐫𝐧𝐢𝐧𝐠 𝐚 𝐟𝐫𝐚𝐦𝐞𝐰𝐨𝐫𝐤 𝐢𝐬 𝐨𝐧𝐞 𝐭𝐡𝐢𝐧𝐠. 𝐊𝐧𝐨𝐰𝐢𝐧𝐠 𝐡𝐨𝐰 𝐭𝐨 𝐮𝐬𝐞 𝐢𝐭 𝐭𝐨 𝐛𝐮𝐢𝐥𝐝 𝐚 𝐫𝐞𝐚𝐥 𝐚𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧 𝐢𝐬 𝐚𝐧𝐨𝐭𝐡𝐞𝐫.

🔗 GitHub repository: https://github.com/epythonlab2/ai-document-api

🎥 Explore the full course series: https://www.youtube.com/watch?v=0SLLG2Z_Htw&list=PLQNCas8_eikM


𝐖𝐡𝐚𝐭 𝐝𝐨 𝐲𝐨𝐮 𝐟𝐢𝐧𝐝 𝐦𝐨𝐬𝐭 𝐜𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐢𝐧𝐠 𝐰𝐡𝐞𝐧 𝐭𝐮𝐫𝐧𝐢𝐧𝐠 𝐚 𝐬𝐢𝐦𝐩𝐥𝐞 𝐀𝐏𝐈 𝐢𝐧𝐭𝐨 𝐚 𝐜𝐨𝐦𝐩𝐥𝐞𝐭𝐞 𝐚𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧?


#FastAPI #Python #APIDevelopment #BackendDevelopment #AIEngineering

As I continue building my AI Document API with FastAPI, I’m reminding myself to look beyond the happy path.

It’s easy to test an endpoint with valid data and celebrate when everything works.

But what happens when:

- The client sends invalid data?

- The requested document doesn't exist?

- A database operation fails?

- A user tries to access something they aren't authorized to access?

For me, the goal isn’t simply to make each endpoint work. It’s to understand how it behaves when things go wrong, too.

That’s one of the things I’m exploring as I build this project step by step with FastAPI.

A good API should handle the expected path well and fail predictably when things go wrong.

As developers, we should test more than whether our code works. We should also test how it fails.

When reviewing an API endpoint, what do you check first: input validation, error handling, or authorization?

🔗 GitHub project: https://github.com/epythonlab2/ai-document-api

🎥 Follow the FastAPI course series: https://www.youtube.com/watch?v=0SLLG2Z_Htw&list=PLQNCas8_eikM


#FastAPI #Python #APIDevelopment #BackendDevelopment #SoftwareEngineering

Stop Accepting AI Code Without Reading It | Review AI-Generated Code
https://youtu.be/mfqI3w4Npsc

AI-Generated Python Code Is Not Always Correct | Code Review
https://youtu.be/mJLwFf0dHSA

Speed Up Pandas: 3 Performance Tips for Faster Dataframes https://youtu.be/3vX1S2qxDu8

🚀 I’m Open to New Opportunities in Python, Machine Learning, and Data Engineering!

I’m looking to connect with individuals, teams, and organizations where I can use my technical skills to solve real-world problems, share knowledge, and create meaningful impact.

Here are three areas where I’d love to contribute:

🔹 Content Creation & Technical Education
Creating practical, engaging tutorials on Python, Machine Learning, and Data Engineering to help developers learn, build, and grow.

🔹 Backend Development & AI Engineering
Building reliable backend systems, ML-powered applications, and APIs using Python, FastAPI, and modern AI/ML technologies.

🔹 Mentoring & Knowledge Sharing
Helping aspiring developers strengthen their Python, Machine Learning, and Data Engineering skills through practical guidance and project-based learning.

💡 What am I looking for?
Opportunities to collaborate on exciting projects, contribute to impactful teams, create educational content, and mentor the next generation of developers.

If you’re hiring, building something interesting, or know someone looking for these skills, I’d love to connect!

📩 Feel free to send me a message or tag someone who might be interested. Let’s build something meaningful together.

#Python #MachineLearning #DataEngineering #FastAPI #AI #BackendDevelopment #Mentorship #ContentCreation #OpenToOpportunities

𝐈 𝐬𝐩𝐞𝐞𝐝 𝐮𝐩 𝐩𝐚𝐧𝐝𝐚𝐬 𝐛𝐲 𝟏𝟎𝟎𝐱, 𝐚𝐧𝐝 𝐡𝐞𝐫𝐞 𝐢𝐬 𝐞𝐱𝐚𝐜𝐭𝐥𝐲 𝐡𝐨𝐰 𝐲𝐨𝐮 𝐜𝐚𝐧 𝐭𝐨𝐨. 🚀

If your DataFrame manipulation feels lightning-fast on a small sample but crawls to a halt on a million rows, you are likely falling into a few common performance traps.

Here are the 3 core optimizations that drove a massive speedup:



1️⃣ 𝐃𝐢𝐭𝐜𝐡 .𝚒𝚝𝚎𝚛𝚛𝚘𝚠𝚜() 𝐟𝐨𝐫 𝐕𝐞𝐜𝐭𝐨𝐫𝐢𝐳𝐚𝐭𝐢𝐨𝐧

Row-by-row looping forces Pandas to create a Series object for every row, bypassing C-level optimizations. Let NumPy and Pandas handle your array math natively.



❌ 𝐒𝐥𝐨𝐰 (𝐑𝐨𝐰-𝐛𝐲-𝐫𝐨𝐰 𝐢𝐭𝐞𝐫𝐚𝐭𝐢𝐨𝐧):

𝚏𝚘𝚛 𝚒, 𝚛𝚘𝚠 𝚒𝚗 𝚍𝚏.𝚒𝚝𝚎𝚛𝚛𝚘𝚠𝚜():

𝚍𝚏.𝚕𝚘𝚌[𝚒, "𝚝𝚘𝚝𝚊𝚕"] = 𝚛𝚘𝚠["𝚙𝚛𝚒𝚌𝚎"] * 𝚛𝚘𝚠["𝚚𝚞𝚊𝚗𝚝𝚒𝚝𝚢"]



✅ 𝟏𝟎𝟎𝐱 𝐅𝐚𝐬𝐭𝐞𝐫 (𝐕𝐞𝐜𝐭𝐨𝐫𝐢𝐳𝐞𝐝 𝐨𝐩𝐞𝐫𝐚𝐭𝐢𝐨𝐧):

𝚍𝚏["𝚝𝚘𝚝𝚊𝚕"] = 𝚍𝚏["𝚙𝚛𝚒𝚌𝚎"] * 𝚍𝚏["𝚚𝚞𝚊𝚗𝚝𝚒𝚝𝚢"]



2️⃣ 𝐒𝐮𝐩𝐞𝐫𝐜𝐡𝐚𝐫𝐠𝐞 𝐌𝐮𝐥𝐭𝐢-𝐂𝐨𝐥𝐮𝐦𝐧 𝐌𝐚𝐭𝐡 𝐰𝐢𝐭𝐡 𝚙𝚍.𝚎𝚟𝚊𝚕()

# 𝙴𝚕𝚒𝚖𝚒𝚗𝚊𝚝𝚎𝚜 𝚝𝚎𝚖𝚙𝚘𝚛𝚊𝚛𝚢 𝚖𝚎𝚖𝚘𝚛𝚢 𝚊𝚕𝚕𝚘𝚌𝚊𝚝𝚒𝚘𝚗 𝚘𝚟𝚎𝚛𝚑𝚎𝚊𝚍

𝚍𝚏["𝚛𝚎𝚜𝚞𝚕𝚝"] = 𝚙𝚍.𝚎𝚟𝚊𝚕("𝚌𝚘𝚕𝟷 + 𝚌𝚘𝚕𝟸 * 𝚌𝚘𝚕𝟹 - 𝚌𝚘𝚕𝟺", 𝚝𝚊𝚛𝚐𝚎𝚝=𝚍𝚏)



3️⃣ 𝐃𝐨𝐰𝐧𝐜𝐚𝐬𝐭 𝐃𝐚𝐭𝐚 𝐓𝐲𝐩𝐞𝐬 & 𝐔𝐬𝐞 𝐂𝐚𝐭𝐞𝐠𝐨𝐫𝐢𝐜𝐚𝐥𝐬

By default, Pandas assigns 64-bit integers/floats and treats string columns as bloated 𝚘𝚋𝚓𝚎𝚌𝚝 types. Downcasting your numbers and converting repeating strings to 𝚌𝚊𝚝𝚎𝚐𝚘𝚛𝚢 can shrink your memory footprint by up to 80%—drastically accelerating every subsequent operation.



# 𝙳𝚘𝚠𝚗𝚌𝚊𝚜𝚝 𝚗𝚞𝚖𝚎𝚛𝚒𝚌𝚜 & 𝚖𝚊𝚙 𝚜𝚝𝚛𝚒𝚗𝚐𝚜 𝚝𝚘 𝚌𝚊𝚝𝚎𝚐𝚘𝚛𝚢

𝚍𝚏["𝚒𝚍"] = 𝚙𝚍.𝚝𝚘_𝚗𝚞𝚖𝚎𝚛𝚒𝚌(𝚍𝚏["𝚒𝚍"], 𝚍𝚘𝚠𝚗𝚌𝚊𝚜𝚝="𝚒𝚗𝚝𝚎𝚐𝚎𝚛")

𝚍𝚏["𝚛𝚎𝚐𝚒𝚘𝚗"] = 𝚍𝚏["𝚛𝚎𝚐𝚒𝚘𝚗"].𝚊𝚜𝚝𝚢𝚙𝚎("𝚌𝚊𝚝𝚎𝚐𝚘𝚛𝚢")



💡 𝐓𝐡𝐞 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲: Optimize your code at the vector and memory level before throwing expensive compute clusters or hardware upgrades at the problem.



What is your favorite performance trick for handling large datasets? Let’s share notes in the comments below! 👇



Explore more https://youtu.be/3vX1S2qxDu8



#Python #Pandas #DataScience #DataEngineering #CodeOptimization #MachineLearning #Programming