Faysal AzizEnquire
FA-0206Software DevelopmentData & Analytics

FastAPI CRUD API Development

Building Production-Ready Database APIs for MariaDB and Oracle using python - 3 days

Introduction

Why this course

This hands-on course focuses on teaching beginners how to build REST API endpoints that perform CRUD (Create, Read, Update, Delete) operations using Python and FastAPI with enterprise databases such as MariaDB and Oracle. CRUD operations form the foundation of almost every data-driven application and represent the essential operations for managing persistent data.

Participants will start from the fundamentals of Python programming and REST API concepts, then gradually progress toward designing and implementing fully functional API endpoints connected to relational databases. The course will also introduce modern best practices such as data validation using Pydantic, database abstraction with SQLAlchemy, project structuring, and API testing through interactive documentation tools.

The instructor for this course brings over 30 years of industry experience, ensuring that the material reflects real industry-demanded development practices rather than purely academic concepts.

Learning outcomes

Learning outcomes

By the end of this training, participants will be able to:

  • Understand how APIs work and how RESTful services expose endpoints
  • Install and configure a Python backend development environment
  • Build web APIs using the FastAPI framework
  • Design and implement CRUD endpoints for database-driven applications
  • Connect FastAPI applications to relational databases such as MariaDB and Oracle
  • Use SQLAlchemy ORM for database interaction
  • Create and validate request/response models using Pydantic
  • Structure backend API projects using maintainable architecture
  • Test APIs using FastAPI's built-in interactive documentation
  • Understand best practices for database sessions, connection pooling, and error handling
Prerequisites

Prerequisites

Participants should have:

  • Basic computer literacy
  • Basic understanding of programming concepts (variables, logic, loops)
  • Basic understanding of databases or SQL (helpful but not mandatory)
  • A laptop with:
    • Python 3.10+ (or ssh capability to access the labs)
    • A code editor: VS Code
    • Access to MariaDB and Oracle database instances (provided as external Labs)
  • Basic command-line familiarity
Training outline

15 modules

·
01Foundations of Web APIs and Backend Development9 topics
  1. Understanding modern backend architectures
  2. Role of APIs in enterprise systems
  3. Overview of REST architecture
  4. HTTP protocol fundamentals
  5. HTTP request and response structure
  6. REST endpoint concepts
  7. API verbs and semantics
    1. GET
    2. POST
    3. PUT
    4. PATCH
    5. DELETE
  8. JSON as a data interchange format
  9. API status codes and error responses
02Python Foundations for API Development9 topics
  1. Overview of Python in backend development
  2. Installing Python development environment
  3. Python package management using pip
  4. Virtual environments for dependency isolation
  5. Python scripting fundamentals
    1. variables and data types
    2. control structures
    3. functions and modules
  6. Python package structure
  7. Importing and managing modules
  8. Introduction to asynchronous programming concepts
  9. Understanding async and await in Python
03Development Environment Setup9 topics
  1. Installing required development tools
  2. Installing FastAPI framework
  3. Installing Uvicorn ASGI server
  4. Installing database drivers
    1. MariaDB connector
    2. Oracle database driver
  5. Installing ORM libraries
    1. SQLAlchemy
  6. Creating a Python project workspace
  7. Running the first FastAPI application
  8. Understanding FastAPI automatic documentation endpoints
  9. Running API servers with Uvicorn
04FastAPI Fundamentals11 topics
  1. Overview of the FastAPI framework architecture
  2. Understanding ASGI servers
  3. Creating a FastAPI application object
  4. Creating basic endpoints
  5. Handling request parameters
  6. Path parameters
  7. Query parameters
  8. Request body handling
  9. Response models and serialization
  10. API documentation using OpenAPI and Swagger UI
  11. FastAPI request lifecycle
05Data Modeling with Pydantic9 topics
  1. Understanding data validation in APIs
  2. Introduction to Pydantic models
  3. Creating request schemas
  4. Creating response schemas
  5. Data validation rules
  6. Field types and constraints
  7. Nested schemas
  8. Serialization and deserialization
  9. Automatic schema generation in OpenAPI documentation
06Introduction to Relational Databases8 topics
  1. Overview of relational database concepts
  2. Tables, rows, and columns
  3. Primary keys and foreign keys
  4. SQL query fundamentals
  5. Data manipulation operations
  6. Schema design considerations
  7. Understanding transactional behavior
  8. Differences between MariaDB and Oracle environments
07Database Integration with Python8 topics
  1. Overview of ORM concepts
  2. Introduction to SQLAlchemy ORM
  3. Benefits of ORM vs raw SQL
  4. Installing and configuring SQLAlchemy
  5. Creating database engine connections
  6. Session management
  7. Database transaction handling
  8. Database connection pooling strategies
08Connecting FastAPI to MariaDB8 topics
  1. Configuring MariaDB database connection
  2. Installing MariaDB Python connector
  3. Creating SQLAlchemy engine for MariaDB
  4. Managing database sessions
  5. Defining database models
  6. Mapping Python classes to database tables
  7. Performing database queries through ORM
  8. Handling connection pooling and performance considerations
09Connecting FastAPI to Oracle Database7 topics
  1. Oracle database driver installation
  2. Creating Oracle connection strings
  3. Configuring SQLAlchemy with Oracle
  4. Handling enterprise database environments
  5. Session lifecycle management
  6. Transaction handling with Oracle
  7. Cross-database compatibility strategies
10Designing CRUD APIs6 topics
  1. Understanding CRUD patterns in API design
  2. Mapping CRUD operations to HTTP methods
  3. Designing resource-oriented endpoints
  4. Endpoint naming conventions
  5. Request and response design patterns
  6. Validation and error handling strategies
11Implementing CRUD Endpoints in FastAPI8 topics
  1. Creating resources with POST endpoints
  2. Retrieving records with GET endpoints
  3. Fetching collections of resources
  4. Fetching individual resources by ID
  5. Updating records with PUT and PATCH endpoints
  6. Deleting records with DELETE endpoints
  7. Database commit and rollback strategies
  8. Handling missing records and validation errors
12Structuring a Scalable FastAPI Project7 topics
  1. Organizing application folders
  2. Separation of concerns in API design
  3. Modular routing using APIRouter
  4. Organizing models, schemas, and services
  5. Configuration management
  6. Environment variables and settings management
  7. Dependency injection patterns
13API Testing and Debugging6 topics
  1. Using Swagger UI for API testing
  2. Using ReDoc documentation interface
  3. Testing endpoints with HTTP clients
  4. Inspecting request and response payloads
  5. Logging and debugging API issues
  6. Handling validation errors and exceptions
14Performance and Best Practices6 topics
  1. Async vs synchronous database access
  2. Connection pooling strategies
  3. Handling database session lifecycle
  4. Preventing common API errors
  5. Input validation and secure coding practices
  6. API versioning strategies
15Preparing APIs for Real-World Deployment6 topics
  1. Running APIs with ASGI servers
  2. Uvicorn configuration
  3. Basic production deployment considerations
  4. API documentation publishing
  5. Monitoring and logging considerations
  6. Scaling APIs for enterprise workloads

A programme built around your team.

Share your training goals and requirements.

Training enquiry

FastAPI CRUD API Development
FA-0206

Share your requirements for this programme.

Training enquiry

FastAPI CRUD API Development