What is an API? A Beginner’s Guide for ML Engineers — Part 1

You open a weather app and instantly see the current temperature.

You log into a website and your profile appears.

You upload an image to an AI application and receive a prediction within seconds.

But how does the application communicate with the system doing all that work behind the scenes?

The answer is APIs.

Overview

• What is an API?
• The Restaurant Analogy
• Why Do We Need APIs?
  • Frontend ↔ Backend Communication
  • Separation of Concerns
  • One API, Many Clients
  • Language Independent
• APIs in Machine Learning
  • How It Works
  • API Integration with Machine Learning
  • ML-Powered Backend Architecture
  • Multi-Platform API Architecture
• Key Takeaways
• Conclusion
• What's Next?

What is an API?

API stands for Application Programming Interface.

An API (Application Programming Interface) is a mechanism that allows two software components to communicate with each other using a defined set of rules, protocols, and data formats.

In simpler terms, an API provides a clear way for one system to ask another system for something — and receive a predictable response in return.

Think of it as a contract between systems:

"If you send me this, I'll give you that."

The Restaurant Analogy

The easiest way to understand an API is through a simple restaurant analogy.

Imagine you're sitting in a restaurant. You don't walk into the kitchen and tell the chef what you want. Instead, you give your order to the waiter.

The waiter takes your request to the kitchen, the kitchen prepares the food, and the waiter brings the result back to you.

An API works in much the same way:

• 🧑 Customer → sends a request
• 🧑‍🍳 Waiter → handles the communication
• 🍳 Kitchen → processes the request
• 🍽️ Food → represents the response

The customer doesn’t need to know what happens inside the kitchen. Similarly, a frontend application doesn’t need to know how the backend performs its internal processing. It only needs to know how to communicate with the API.

Why Do We Need APIs?

Modern applications are rarely built as a single piece of software. Instead, they are usually divided into different layers, such as the frontend, backend, and database.

Each layer has a different responsibility, but they still need a way to communicate with each other. APIs provide that communication bridge.

Frontend ↔ Backend Communication

The frontend is what users interact with, while the backend handles the application logic behind the scenes. An API connects the two.

The frontend sends an HTTP request to an API. The backend processes the request, fetches data if necessary, and returns a response — often in JSON format.

Separation of Concerns

APIs also help us keep different parts of an application independent. Instead of putting the frontend, backend, and database logic together, each layer can focus on its own responsibility.

This separation makes an application easier to scale, maintain, and develop as the project grows.

• ✅ Scalable — each layer can be scaled independently when needed.
• ✅ Maintainable — backend logic can change without requiring major changes to the frontend.
• ✅ Collaborative — frontend and backend developers can work on their respective layers in parallel.

The API becomes the contract that keeps these layers connected without tightly coupling their internal implementation.

One API, Many Clients

A single backend API can support multiple client applications. The same API might serve a web application, a mobile application, and a desktop application without requiring separate backend logic for each client.

This is one of the biggest advantages of APIs: the backend can expose a consistent interface while different clients consume it in their own way.

• Web frontend → communicates with the API through HTTP requests.
• Mobile app → uses the same API to retrieve or update data.
• Desktop application → can consume the same backend services.

As long as each client follows the API’s contract, the backend doesn’t need to know whether the request came from a browser, a phone, or another application.

Language Independent

APIs are technology independent. This means applications built using different programming languages can communicate with the same backend service.

For example, a Java application, a Python application, and a PHP application can all consume the same API. They don’t need to be written in the same language as the backend.

What matters is that they follow the API’s communication rules. The clients can send requests using HTTP and exchange data using a common format such as JSON.

• Java application → consumes the API
• Python application → consumes the same API
• PHP application → consumes the same API

The API provides the common interface between them, allowing different technologies to communicate without needing to know how the backend itself is implemented.

Different languages, same API.

APIs in Machine Learning

This is where it gets interesting for ML engineers. Instead of serving predictions from a script, you wrap your model in an API. This pattern is exactly what FastAPI is built for — a modern, fast Python framework for building ML-ready APIs.

How It Works

1. Frontend sends user data — for example, an image or text, to the API.
2. Backend API receives the data — and passes it to the ML model.
3. ML model runs inference — and generates a prediction.
4. API sends the prediction back — to the frontend.

There are several ways to structure this integration. Let's look at three common architectural perspectives.

API Integration with Machine Learning

This architecture demonstrates how machine learning models can be integrated into backend systems using APIs.

The frontend sends data to the backend API, the backend communicates with the ML model, and predictions or results are returned back to the user.

ML-Powered Backend Architecture

In this setup, the backend handles the application logic while the ML model performs predictions or intelligent processing.

The API exposes endpoints that allow frontend applications to interact with machine learning services in real time.

How the architecture works

• Client application sends a request — for example, a chatbot message, product query, or document-related request.
• API receives the request — and routes it to the appropriate backend functionality.
• Backend processes the request — handling business logic, data processing, and preparing the input for the ML model.
• ML model performs inference — generating a prediction, recommendation, or other intelligent result.
• Backend returns the result — and the API sends the response back to the client application.

This architecture keeps the ML model behind the backend API. The client does not need to know how the model is implemented; it only needs to follow the API contract.

Multi-Platform API Architecture

A single API can support multiple frontend platforms, including websites, Android apps, and iOS applications.

Instead of building separate backend systems for each platform, all clients can communicate with the same API and share the same backend logic.

Using a shared backend improves scalability, simplifies maintenance, and helps ensure consistent data flow across different platforms.

How It Works

• Website frontend sends a request — through the API to access application data or functionality.
• Android application uses the same API — without requiring a separate backend.
• iOS application uses the same API — following the same API contract.
• API routes the requests to the backend — where business logic and data processing are handled.
• Backend communicates with the ML model — when intelligent processing or predictions are required.
• Response is returned to the requesting client — regardless of which platform initiated the request.

The important idea is that the API becomes the common interface between different platforms and the backend.

The website, Android app, and iOS app may have completely different user interfaces and technologies, but they can still consume the same backend services through a consistent API.

One backend, multiple platforms, one API contract.

Key Takeaways

Conclusion

APIs are the bridge that allows different parts of a modern application to communicate. They separate responsibilities, let multiple clients share the same backend, and allow applications built with different technologies to work with the same services.

For machine learning, this becomes even more useful. An API can turn a trained model into a service that websites, mobile applications, and other systems can consume without needing to understand the model's internal implementation.

With these fundamentals in place, we can now move from understanding APIs to building them with FastAPI.

What's Next?

Now that you understand what an API is, why we need one, and how APIs can connect different applications and machine learning models, the next step is to build one.

In the next post, we’ll move from concepts to code and explore the architecture behind FastAPI. You’ll learn:

• FastAPI’s Core Architecture: How FastAPI uses Starlette for web handling and Pydantic for data validation.
• ASGI vs WSGI: How ASGI enables asynchronous request handling and why it makes FastAPI well suited for modern applications.
• Your First API: How to create a main.py file, run the Uvicorn server, and explore FastAPI’s automatic interactive documentation.
• Building with FastAPI: How these concepts come together to create a real API that can later be extended for machine learning.

Series: FastAPI for Machine Learning — Part 1 of 12