<h2>1.Introduction to FastAPI</h2>FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.7+ based on standard Python type hints. It was created to make building APIs easy, fast, and fun while maintaining high performance.Unlike older frameworks like Flask or Django REST Framework, FastAPI uses Python type declarations to provide automatic data validation, serialization, and interactive API documentation.Because of its modern features, FastAPI is widely used in production by companies such as Microsoft, Uber, and Netflix.<h2>2.What is an API and RESTful APIs?</h2> API stands for Application Programming Interface. It is a set of rules and tools that allows different software applications to communicate with each other. Think of an API as a waiter in a restaurant who takes your order and brings the food from the kitchen. In web development, APIs allow clients (like web browsers or mobile apps) to communicate with servers to request or send data. For example, when you use an app to check the weather, the app uses an API to get weather data from a remote server. REST (Representational State Transfer) is a popular architectural style for designing web APIs. RESTful APIs use HTTP methods (GET, POST, PUT, DELETE) to perform operations on resources, which are identified by URLs. For example: GET /users &mdash; fetches a list of users POST /users &mdash; creates a new user PUT /users/1 &mdash; updates user with ID 1 DELETE /users/1 &mdash; deletes user with ID 1 FastAPI is designed to make building RESTful APIs simple and fast, by providing tools to define these HTTP operations and handle data efficiently.<h2>3.Why FastAPI? Key Features and Advantages</h2> FastAPI has quickly gained popularity among developers for several reasons. Here are some of its key features and advantages: 1.High Performance: FastAPI is one of the fastest Python web frameworks available, thanks to its use of the asynchronous capabilities of Python and the efficient Starlette and Pydantic libraries. 2.Easy to Learn and Use: Its design emphasizes simplicity and developer productivity. The syntax is clean, and it leverages Python type hints to reduce bugs and make the code more readable. 3.Automatic Interactive API Documentation: FastAPI automatically generates interactive API docs using Swagger UI and ReDoc. This makes testing and understanding the API much easier. 4.Data Validation and Serialization: Using Pydantic models, FastAPI validates request data and serializes responses automatically, saving developers from writing repetitive code. 5.Asynchronous Programming Support: FastAPI supports Python&rsquo;s async and await keywords, allowing developers to build high-performance asynchronous APIs easily. 6. Dependency Injection System: FastAPI includes a simple but powerful dependency injection system, which helps in managing components like database connections, security, and configuration cleanly. 7. Security and Authentication: Built-in tools help implement OAuth2, JWT tokens, and other authentication methods quickly. 8. Great Community and Ecosystem: FastAPI has an active community and plenty of third-party packages, tutorials, and resources.
<h2>4.Installing FastAPI and Setting up Your Environment</h2> Before you start coding with FastAPI, you need to set up your development environment and install the required packages. FastAPI works well with Python 3.7 and above. Step 1: Create a virtual environment (optional but recommended) Using a virtual environment keeps your project dependencies isolated from your system Python. To create and activate a virtual environment, run:<pre><code>python3 -m venv env
 source env/bin/activate # On Windows: env\Scripts\activate</code></pre>Step 2: Install FastAPI and Uvicorn FastAPI itself is just the framework, but to run the application, you need an ASGI server. Uvicorn is a popular, fast ASGI server used with FastAPI. Install them using pip:<pre><code>pip install fastapi uvicorn</code></pre>Step 3: Verify the installation You can check the versions installed by running: <pre><code>pip show fastapi uvicorn</code></pre>If everything is installed correctly, you&rsquo;re ready to build your first FastAPI app! <h2>5.Building Your First FastAPI Application</h2> Let's create a simple FastAPI app that returns a greeting message when you visit the root URL.<pre><code>app = FastAPI()
 
 @app.get("/")
 def read_root():
 &nbsp;&nbsp;&nbsp; return {"message": "Hello, FastAPI!"}</code></pre>Explanation: We import FastAPI from the fastapi package. Create an instance of FastAPI named app.Define a path operation with the @app.get("/") decorator to handle GET requests at the root URL. The function read_root returns a JSON response with a message. To run the application, use this command in your terminal:<pre><code>uvicorn main:app --reload</code></pre>main is the filename (without .py). app is the FastAPI instance --reload enables auto-reload on code changes (good for development).Open your browser and visit http://127.0.0.1:8000/. You should see:<pre><code>{"message":"Hello, FastAPI!"}</code></pre>Congratulations! You just built your first FastAPI application.
<h2>6. Understanding Path Operations (Routes)</h2>In FastAPI, path operations (also called routes or endpoints) define how your application responds to client requests at specific URLs and HTTP methods.Each path operation is created using decorators like @app.get(), @app.post(), @app.put(), and @app.delete(). These correspond to HTTP methods GET, POST, PUT, and DELETE.For example:<pre><code>from fastapi import FastAPI
 app = FastAPI()
 @app.get("/items/{item_id}")
 def read_item(item_id: int):
 &nbsp; &nbsp; return {"item_id": item_id}
 @app.post("/items/")
 def create_item(name: str):
 &nbsp; &nbsp; return {"name": name}</code></pre>The first function responds to GET requests at /items/{item_id}, where item_id is a path parameter.The second function responds to POST requests at /items/ and expects a query parameter name.<h3>Path Parameters</h3> You can declare variables in the path by using curly braces {}. FastAPI automatically converts them to the specified type and validates them.<h3>Query Parameters</h3> Parameters that are not part of the path are called query parameters and are passed after the ? in the URL.<h3>Query Parameters</h3> Parameters that are not part of the path are called query parameters and are passed after the ? in the URL. For example: /items/?name=book<h2>7. Request and Response Handling</h2> In FastAPI, handling requests and responses is straightforward and flexible. You can access data sent by the client and return various types of responses. Accessing Request Data: Request data can come from different parts such as: Path Parameters: Variables defined in the URL path. Query Parameters: Variables passed in the URL after ?. Request Body: Data sent in the body of POST, PUT, or PATCH requests, usually in JSON format. Headers: Metadata sent in HTTP headers. Cookies: Data stored in client cookies. Example: Reading Path, Query, and Body Data<pre><code>from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
 name: str
 price: float
@app.post("/items/{item_id}")
def create_item(item_id: int, item: Item, q: str = None):
 return {"item_id": item_id, "item": item, "q": q}</code></pre>item_id is a path parameter. item is the request body parsed as an Item model. q is an optional query parameter.
<h3>Returning Responses:</h3> By default, FastAPI returns JSON responses. You can also customize response types, status codes, and headers. Example:
<pre><code>from fastapi import Response
@app.get("/custom")
def custom_response():
 return Response(content="Custom response", media_type="text/plain")</code></pre><h2>8.Data Validation and Serialization with Pydantic</h2> FastAPI uses Pydantic models to validate and serialize data. Pydantic leverages Python type annotations to check that the data conforms to the expected types and formats, reducing bugs and improving code reliability. Defining a Pydantic Model:You define a Pydantic model by creating a class that inherits from BaseModel, and then declaring attributes with their types. Example:<pre><code>from pydantic import BaseModel
class Item(BaseModel):
 name: str
 description: str = None # Optional field
 price: float
 tax: float = None</code></pre>The description and tax fields are optional because they have default values. FastAPI automatically converts incoming JSON data into this model and validates it. <h3>Using Pydantic Models in FastAPI</h3> You can use Pydantic models as request bodies and responses. FastAPI uses the model schema to validate input and generate API documentation. Example:<pre><code>from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
 name: str
 price: float
@app.post("/items/")
def create_item(item: Item):
 return item</code></pre>Here, FastAPI expects a JSON object with name and price fields in the request body, validates them, and returns the same data in the response.<h2><h2><h2><h2>9. Using Async Features for Better Performance</h2><h6>FastAPI fully supports Python's asynchronous programming features using the async and await keywords. This allows you to write code that can handle multiple requests concurrently without blocking the execution.</h6>Why Use Async?<h6>In web applications, some operations like database queries or external API calls can take time. If these operations are blocking (synchronous), the server waits for them to finish before handling other requests, which reduces performance.</h6>When Not to Use Async?<h6>If your endpoint only performs quick CPU-bound operations and does not call external async libraries, using async may add unnecessary complexity.</h6><h2>10.Conclusion: Wrapping up your FastAPI Journey</h2> <h6>FastAPI isn&rsquo;t just a modern web framework . it&rsquo;s a gateway to building efficient, scalable, and high-performance APIs with minimal code and maximum clarity. Throughout this blog, we&rsquo;ve explored its powerful features like automatic docs, async support, Pydantic-based data validation, and how easily it integrates into real world projects.</h6> <h6>Whether you're building a personal project, a startup MVP, or a large scale microservice, FastAPI has your back.</h6><h6>Remember: good structure, async functions, and data validation are your best friends here.</h6><h6>But don&rsquo;t stop here &nbsp;this blog was just a simple roadmap. If you want to dive deeper and master FastAPI like a pro, I highly recommend the official documentation:</h6><h6><a href="https://fastapi.tiangolo.com">https://fastapi.tiangolo.com</a></h6><h6>Start building something cool, test it, scale it and let FastAPI do the heavy lifting.</h6>

A complete guide to FastAPI, covering everything developers need to know to build efficient and modern APIs from scratch.

From zero to hero with FastAPI: The fastest way to build modern APIs in python | Tech Tips By Moh

From zero to hero with FastAPI: The fastest way to build modern APIs in python

A comprehensive guide to Artificial Intelligence — including its history, core concepts like machine learning and neural networks, real-world applications, ethical concerns, and future trends shaping technology and society.

Exploring the World of Artificial Intelligence

Learn how to use OpenAI API for developing AI-driven solutions, including creating projects like ChatGPT, with a focus on reusable and scalable coding practices using Django for backend development.

Tech Tips By Moh | Creating AI-driven Solutions with OpenAI API

Creating AI-driven Solutions with OpenAI API

Take your Docker skills to the next level in Part 2 of our guide. Learn how to write Dockerfiles, manage containers and images, use volumes and networking, and orchestrate multi-service apps with Docker Compose. Discover best practices to build production-ready applications with Docker.

Docker Explained: Advanced Concepts & Best Practices (Part 2)| Tech Tips By Moh

Docker Explained: Advanced Concepts & Best Practices (Part 2)

<h2>Live Progress Updates in Long-Running Backend Tasks: Polling vs WebSocket</h2> When your backend is handling long tasks like crunching big files, training a model, or working with AI APIs showing just a spinner until it&rsquo;s done is painful for users. A better way? Show live progress updates while the task is running, so users know something is happening. &nbsp; <h3>Why Live Updates Matter:</h3> Nobody likes waiting in the dark. Imagine uploading a 500-page PDF and staring at a loader for minutes. Instead, if the app shows progress updates after each page, users stay engaged and can even start using partial results before everything finishes. It makes the whole experience feel faster and more interactive. <h3>Method 1: Polling</h3> How it works The frontend keeps asking the backend every few seconds: &ldquo;What&rsquo;s the progress now?&rdquo; 1. User starts a task. 2. Backend processes the work. 3. Progress is stored (e.g., in Redis) with a unique ID. 4. Frontend hits a &ldquo;progress&rdquo; endpoint on repeat. 5. Backend returns the current status until the task is done. &nbsp; Pros: Super easy to implement. Works everywhere, no special setup. Cons: More network traffic (lots of repeated requests). Updates are tied to the polling interval, not truly real-time. &nbsp; <h3>Method 2: WebSocket</h3> How it works Instead of asking again and again, the frontend opens a WebSocket connection. From there, the backend can push updates instantly as they happen. Typical flow: 1. Frontend opens a WebSocket connection. 2. Backend runs the task and streams progress updates over that connection. 3. Frontend updates the UI immediately. Pros: Real-time updates with no delay. Less network overhead. Perfect for live dashboards, chat apps, and AI progress updates. Cons: More complex to set up and scale. Requires support on both frontend and backend. &nbsp; <h3>Practical Example:</h3> Here&rsquo;s a simple Python example to simulate progress: import time for i in range(101):&nbsp; # 0 to 100% &nbsp;&nbsp;&nbsp; time.sleep(0.2)&nbsp;&nbsp; # simulate work &nbsp;&nbsp;&nbsp; # send progress via cache (Polling) or WebSocket <ul> <li>With Polling, you&rsquo;d write progress to cache and let the frontend check it on intervals.</li> <li>With WebSocket, you&rsquo;d push progress directly to the client every step.</li> </ul> <h3>When to Use Polling vs WebSocket</h3> Polling is a good fit when: <ul> <li>Setting up WebSockets is hard in your environment. </li> <li>You don&rsquo;t need instant updates.</li> </ul> WebSocket is better when: <ul> <li>You want real-time, no-delay updates. </li> <li>You&rsquo;d like to cut down on repeated HTTP calls.</li> <li>Your app is interactive (chat, live feeds, dashboards).</li> </ul> <h3>Conclusion:</h3> Live progress updates change the way users experience your app. Whether it&rsquo;s AI, data crunching, or file handling showing progress in real time keeps users confident and engaged. Polling is simple and reliable; WebSocket is faster and more interactive. Pick the one that fits your setup best. Pro Tip: Using Django? Try Django Channels for WebSockets and Redis for progress tracking in both approaches.

Learn how to improve user experience in long-running backend tasks with live progress updates. Compare Polling vs WebSocket and choose the best real-time solution.

Live Progress Updates in Long-Running Backend Tasks: Polling vs WebSocket | Tech Tips By Moh

Live Progress Updates in Long-Running Backend Tasks: Polling vs WebSocket

<h2>Remove Image Background and Blend Images Using Python</h2>


 Looking to elevate your Python image processing skills? In this guide, you'll learn how to remove the background from an image using Python and blend it with another image using NumPy. It’s a simple yet powerful technique I recently shared in a video tutorial.


<h3>🎬 What This Tutorial Covers</h3>


 We'll walk through the process of combining two powerful Python libraries — rembg and NumPy — to create clean, professional-looking image composites. This is perfect for:


<ul>
 <li>Automating image post-processing workflows</li>
 <li>Creating thumbnails and social media visuals</li>
 <li>Building tools for AI/ML datasets</li>
 <li>Designing profile images or marketing content</li>
</ul>

<h3>📌 Step 1: Remove the Image Background with rembg</h3>


 The <a href="https://github.com/danielgatis/rembg" target="_blank" rel="noopener noreferrer">rembg Python library</a> lets you remove an image’s background using deep learning — no manual editing needed.


To remove a background:

<ol>
 <li>Install the rembg library using pip.</li>
 <li>Read the image file in binary mode.</li>
 <li>Pass the binary data to the remove function from rembg.</li>
 <li>Convert the output into an image and save it in PNG format.</li>
</ol>


 This results in a clean, background-free image that you can easily layer or reuse.


<h3>📌 Step 2: Blend Foreground and Background with NumPy</h3>


 Once you have the image without a background, you can blend it with a new background image using NumPy. Here’s how the process works:


<ol>
 <li>Resize both the foreground and background images to match in dimensions.</li>
 <li>Convert both images into NumPy arrays and use float values for blending.</li>
 <li>Apply a weighted sum using your preferred blend ratios (e.g., 80% foreground and 20% background).</li>
 <li>Convert the final array back into an image and save it as your final result.</li>
</ol>


 This lets you control how much of each image appears in the final result. You can experiment with different weights for creative effects.


<h3>📦 Full Code and GitHub Repository</h3>


 Want to try it yourself? I’ve published a complete working example you can clone and run. It includes sample images and instructions:



 👉 <a href="https://github.com/mmmohajer/image-overlay-and-grayscale" target="_blank" rel="noopener noreferrer">Image Background Removal and Blending – GitHub Repository</a>


<h3>🌟 Final Thoughts</h3>


 By combining rembg, Pillow, and NumPy, you can create powerful workflows for creative image editing, AI preprocessing, or content generation. Whether you're automating image cleanups or making dynamic visuals, this technique is a great place to start.



 If this tutorial was helpful, feel free to explore more on my GitHub or share this guide with fellow Python enthusiasts!

Learn how to remove image backgrounds using Python’s rembg library and blend images with NumPy for stunning effects. Explore the full code and try it yourself!

Removing Backgrounds and Blending Images with Python: A Simple Guide| Tech Tips By Moh

Removing Backgrounds and Blending Images with Python: A Simple Guide

If you&rsquo;re starting your journey in web development, you&rsquo;ve probably heard advice like this: &ldquo;Learn JavaScript, Python, and C++&mdash;you&rsquo;ll be a full-stack developer in no time!&rdquo; &ldquo;Master frontend and backend together&mdash;it&rsquo;s the fastest way to get a job!&rdquo; It sounds promising, but here&rsquo;s the truth: Trying to learn too many programming languages and frameworks at once is the fastest way to get stuck. <h2>Why Learning Too Many Languages Can Hurt Your Progress</h2> When new developers try to juggle multiple languages like JavaScript, Python, C++, and Java all at the same time, they spread their energy too thin. It&rsquo;s overwhelming, and instead of becoming a master in one area, they end up with surface-level knowledge that doesn&rsquo;t help them land a job or build real projects. This problem is so common that I made a video about it&mdash;watch it now to avoid falling into this trap! <h2>Why You Should Focus on One Language or Framework</h2> Here&rsquo;s the truth: ✅ Depth beats breadth. Learning one language deeply&mdash;like JavaScript with React for frontend or Python with Django for backend&mdash;helps you build real-world projects and solve real problems. ✅ Confidence comes from mastery. When you understand the core concepts of one stack, you&rsquo;ll find it much easier to pick up new tools later, like Docker, Redis, or CI/CD pipelines. ✅ Projects matter more than tutorials. Building a few solid projects teaches you far more than watching endless courses. <h2>How My Mentoring Can Help You</h2> If you feel overwhelmed by all the options, don&rsquo;t worry&mdash;you&rsquo;re not alone. In my mentoring program for aspiring web developers, I&rsquo;ll help you: <ul> <li> Choose the right tech stack based on your goals (e.g., frontend with React or backend with Django). </li> <li> Build hands-on projects that strengthen your skills. </li> <li> Stay focused on what really matters, so you can avoid getting distracted by the latest shiny tools. </li> </ul> The best part? The<a href="https://calendly.com/mohammad-aqd6/30min"> first mentoring session is free</a>&mdash;we&rsquo;ll explore your goals, your current skills, and create a clear, personalized plan for your learning journey. <hr> <h2>👩&zwj;💻 Ready to Start Your Web Development Journey the Right Way?</h2> 🎯 <a href="https://calendly.com/mohammad-aqd6/30min">Book your free mentoring session today</a> and let&rsquo;s build a roadmap for your success.

New web developers often struggle by learning too many programming languages at once. This blog explains why focusing on one language like JavaScript or Python can boost your skills and career faster.

From zero to hero with FastAPI: The fastest way to build modern APIs in python

Recent Blogs

Exploring the World of Artificial Intelligence

Creating AI-driven Solutions with OpenAI API

Docker Explained: Advanced Concepts & Best Practices (Part 2)

Recent Tips

Live Progress Updates in Long-Running Backend Tasks: Polling vs WebSocket

Removing Backgrounds and Blending Images with Python: A Simple Guide

The Biggest Mistake New Developers Make

Stay In Touch