Skip to content

Python Microservices and REST API Development

About

  • Level: Intermediate to Advanced
  • Lectures: 30 hours
  • Self-study: 15 hours
  • Exercises: 24
  • Lines of Code to write: ~500
  • Format: e-learning + weekly online teleconference with instructor
  • Language: English or Polish

Description

This hands-on training course teaches how to design and build production- ready Python microservices and REST APIs by following the syllabus from network fundamentals to deployment. Topics include networking and HTTP principles, API design with OpenAPI and versioning, practical use of frameworks such as FastAPI and Django, database integration (SQL and NoSQL, raw queries and ORMs), authentication and authorization (OAuth2, JWT), architectural patterns (API Gateway, BFF, queues, caching), and DevOps practices for testing, CI/CD, containerization, and orchestration. Labs focus on building, testing, and deploying real services to reinforce best practices for reliability and observability.

Advantages

Participants will be able to design clear, well-documented APIs and choose appropriate frameworks and persistence for their needs, which shortens development cycles and reduces integration friction. The course teaches scalability and resilience patterns (load balancing, queues, caching), plus CI/CD and containerization skills, improving time to production, fault tolerance, monitoring, and operational readiness for teams.

Target Audience

  • Backend and API developers building RESTful services and microservices.
  • Software architects and technical leads evaluating microservice patterns and deployment strategies.
  • DevOps engineers and SREs who deploy, scale, and monitor distributed services in production.
  • Data engineers integrating databases, ETL pipelines, and analytics with microservices.
  • QA engineers and test authors who write integration, contract, and system tests for APIs.
  • Advanced students and developers seeking practical, production-focused experience with Python microservices, FastAPI/Django, and containerized deployments.

Format

The course is delivered as a blended learning experience, comprising numerous short videos that progressively introduce concepts and techniques through a series of practical examples. The course format combines e-learning modules with weekly online teleconferences with the instructor for Q&A, discussions, and code reviews.

During the self-study phase, students complete practical exercises that apply the learned techniques. Each exercise is designed to have 100% test coverage, allowing students to verify their solutions. Additionally, students will have access to a spreadsheet to track their progress.

Students will also receive downloadable resources, including code samples, exercise templates, and reference materials to support their learning journey. Since 2015, we have refined our materials based on student feedback to ensure clarity, engagement, and practical relevance. All code listings undergo automatic testing (over 28,000 tests) to ensure accuracy and reliability. All materials, code listings, exercises, and assignments are handcrafted by our trainers without the use of AI. All case studies and examples are based on real-world scenarios drawn from our extensive experience in software engineering.

Working language of the course is either English or Polish.

Course Outline

  1. Introduction to networking concepts:

    • OSI model
    • IPv4 and IPv6 protocols
    • TCP and UDP protocols
    • HTTP and HTTPS protocols
    • HTTP versions 1.1, 2.0, 3.0

  2. HTTP protocol:

    • Client–server communication (Request–Response)
    • HTTP request lifecycle
    • HTTP request methods
    • Response status codes
    • Request and response headers
    • MIME types
    • Retrieving data from a server
    • Sending data to a server
    • Debugging (curl, Web Inspector, Wireshark, tcpdump)

  3. Application API design:

    • REST protocol
    • JSON serialization and deserialization
    • Documentation: OpenAPI
    • API design principles
    • API versioning

  4. Introduction to frameworks:

    • FastAPI
    • Django

  5. Introduction to databases:

    • SQL vs. NoSQL
    • Raw SQL queries
    • Using an ORM in an application
    • Database usage examples: SQLite3, PostgreSQL, MongoDB, InfluxDB, Prometheus

  6. Authorization and authentication:

    • Basic Auth
    • OAuth2
    • JSON Web Token (JWT)

  7. Architecture:

    • Vertical and horizontal scalability concepts
    • Monolithic vs. microservices architecture
    • Asynchronous and synchronous network communication
    • Models: API Gateway, Backend for Frontend (BFF)
    • Load balancing
    • Queues: Redis + Celery
    • Cache: Memcached, Redis, Varnish

  8. DevOps:

    • Testing
    • CI/CD pipeline
    • Deployments and introduction to containerization (Docker, Kubernetes)

Our Experience

AATC trainers have been teaching software engineering since 2015. We have already delivered over 11,000 (eleven thousand) hours of software engineering training to more than 32,000 (thirty-two thousand) students worldwide.

Requirements

  • Intermediate knowledge of Python programming
  • Familiarity with using an IDE (e.g., PyCharm, VSCode)
  • Familiarity with using version control systems (e.g., Git)

Setup

  • Newest version of Python
  • IDE of your choice (e.g., PyCharm, VSCode)
  • Git installed and configured
  • GitHub account
  • Web browser (e.g., Chrome, Firefox, Safari, etc.)
  • SQLite3 installed locally

Apply

If you are interested in taking this course, please contact us at info@astronaut.center