Programming · Intermediate
Build a full API test automation framework in Python from scratch
One growing project, short video lessons and code review on every homework, taking you from core libraries to coverage, reporting and notifications.
- Short 5–20 minute video lessons
- Weekly hands-on homework
- Detailed code review feedback
- One project from start to finish
- Access for a full year
- 14-day refund policy
Why API tests so often turn into a mess
Many QA engineers can write a single test that sends a request and checks a status code. The trouble starts when the project grows. Requests are copied from file to file, test data lives in random places, reports are unreadable and nobody dares to refactor anything.
Most free material stops at the first request. It rarely shows how to structure a framework, how to wrap a client so tests stay short, how to work with a database, or how to publish results so that the whole team can read them.
This programme is built around that gap. Instead of isolated examples you work on a single project that gets bigger and more realistic every week. You start with the core libraries and end with coverage, reporting and notifications, so by the final lesson you have a working framework and understand why each part exists.
The course is demanding on purpose. It is meant for people who already touch testing or Python in their daily work and want to move from scattered scripts to a maintainable, professional approach to back-end automation.
What you will be able to do
- Deploy a test application with Docker
Run and stop the system under test in containers on your own machine.
- Build an API client from a specification
Use Swagger, Postman and cURL to explore the service and generate a working client.
- Wrap clients with facades and helper classes
Keep tests short and readable by hiding transport details.
- Validate data with typed models
Describe requests and responses with pydantic models and catch contract errors early.
- Add logging and decorators to your framework
Make every request traceable and reduce repeated code.
- Work with databases from tests
Prepare and verify data through ORM models and clean it up reliably.
- Organise fixtures and project files
Structure conftest and requirements files, and extract reusable code into separate packages.
- Generate code for REST and gRPC
Produce clients automatically instead of writing them by hand.
- Publish reports, coverage and notifications
Turn test runs into clear results that the team receives automatically.
- 7
- weeks of structured learning
- 7
- modules in the programme
- 5–20 min
- per video lesson
- 2–3 h
- of homework, about once a week
One project that grows with you
Instead of starting a new demo every lesson, you keep working on the same framework. The application under test is close to a real product: it has a back end, a user interface and a mail service, so the problems you solve resemble the ones you meet at work.
Every week the project becomes more complex. You refactor earlier code, move shared parts into packages and see for yourself why good structure saves time later. Each homework is reviewed like a pull request, with comments on the code itself.
- Theory and practice in the same lesson
- Thousands of lines of code written by you
- Review comments on every submitted task
- A finished framework you can adapt to your own projects
How the course works
The whole programme runs online. Lessons open on a schedule in your personal account, and each lesson contains from one to five short videos of 5 to 20 minutes, so you can fit them into a break or an evening. Most lessons also come with a short written summary, which is handy when you want to find a detail again.
Homework is assigned about once a week and usually takes two to three hours. You submit your code, and the instructor returns a detailed review in the style of a code review. You also have a closed group chat to ask questions and compare solutions with other participants.
The pace is intensive, and learners who combine the course with a full-time job often say it takes planning. Look at your calendar before you start, block time for the weekly task and treat the deadlines as part of the training.
The programme
Seven modules, one per week, each building on the same project.
1Week 1 — Foundations and the test environmentRefresh the Python you need and get the application running.Short video lessons with homework
- Python refresher for test automation
- Running the application under test in Docker
- Exploring the API with Swagger, Postman and cURL
- Creating the project and virtual environment
2Week 2 — The API clientSend your first requests and shape them into a reusable client.Short video lessons with homework
- Building a REST API client
- Handling responses and errors
- Writing the first automated checks
- Keeping configuration out of the code
3Week 3 — Facades, wrappers and loggingMake the framework readable and traceable.Short video lessons with homework
- The facade class for service operations
- Wrapper classes over the client
- Logging every request and response
- Decorators that remove repetition
4Week 4 — Typed data and validationDescribe the contract with models.Short video lessons with homework
- Data models with pydantic
- Validating responses against models
- Building test data with helpers
- Negative scenarios and error contracts
5Week 5 — Databases and fixturesPrepare and verify data below the API layer.Short video lessons with homework
- Connecting to the database from tests
- Working with ORM models
- Designing fixtures and conftest files
- Cleaning up test data safely
6Week 6 — Packages and code generationExtract shared code and automate client creation.Short video lessons with homework
- Moving shared code into separate packages
- Managing requirements and package builds
- Generating a REST client automatically
- Working with gRPC requests and generated code
7Week 7 — Coverage, reports and notificationsClose the loop and make results visible to the team.Short video lessons with homework
- Measuring API test coverage
- Building test reports with logs attached
- Sending run results as automatic notifications
- Final refactoring and project review
What you get
- Video lessons
Short, focused videos with no filler, opened on a weekly schedule.
- Written summaries
Condensed text versions of the explanations for quick reference.
- Weekly practical tasks
Homework that extends one real project, week after week.
- Code review feedback
Detailed comments on your solutions from the instructor.
- A private group chat
A place to ask questions and learn from other participants.
- Links to extra materials
Further reading for every topic that deserves a deeper look.
- A working framework
A complete project you can reuse as a reference in your own work.
- A full year of access
Return to any lesson as often as you need.
Is this course for you?
This course is for you if…
- QA engineers who already write some automated tests and want a professional framework structure
- Python developers who want to test back-end services systematically
- Manual testers who have solid Python basics and want to move into API automation
- Engineers who automate the user interface and want to understand back-end testing
Probably not a fit if…
- Complete beginners in testing who have never written automated tests
- People who have not yet learned Python basics, such as functions, classes and the principles of object-oriented programming
- Anyone looking for a light, theory-only overview
- Learners who cannot set aside a few hours each week for practice
After the course
By the final week you have a complete API test automation project that you built yourself, with a clear structure, typed models, database access, fixtures, reports and notifications. You will know why each part is there, which makes it much easier to explain and defend your decisions in a team.
You can take the same patterns to your own work: wrap a client, extract reusable packages, generate clients from specifications and publish results automatically. Many participants find that they come back to their finished code as a reference whenever a new project starts.
Because access stays open, you can repeat the topics that felt heavy the first time. The material is dense, and a second pass is often when the full picture comes together.
Questions before you enrol
How much time do I need each week?
Plan for the video lessons, which are short, plus about two to three hours for the weekly homework. If you work full time, set the hours aside in advance, because the pace is intensive.
What do I need to know before starting?
You should be comfortable with Python basics, including functions, classes and the main ideas of object-oriented programming, and have some familiarity with testing APIs. Complete beginners in automation will find it very hard.
How does access work after payment?
After you pay, the programme appears in your personal account. Lessons open on the schedule, and your access lasts for a full year.
What is the refund policy?
You can request a refund within 14 days of purchase if the course is not what you expected.
In what format are the lessons?
Short video lessons of 5 to 20 minutes, supported by written summaries, links to further materials and weekly hands-on tasks.
Will I get feedback on my work?
Yes. Your homework is reviewed in the style of a code review, with comments on the code, and you can ask questions in the group chat.
Does the material stay available after the programme ends?
Yes. You can return to the lessons and summaries during your access period and rewatch any topic until it is clear.
Is there a deadline for homework?
Tasks are assigned roughly weekly and have deadlines that keep the group moving. Planning your calendar before you start makes the pace easier to manage.
Build your API test framework step by step
Join the programme and finish with a working project and clear, reusable patterns.