Python Engineering Lab

What this project shows

The Python Engineering Lab is a completed, hands-on software engineering project. I built a workout-tracking application step by step to strengthen my Python and backend engineering skills.

Rather than completing ten unrelated tutorials, I developed one application through ten stages. It began as a small service that could receive and return workout data. With each stage, I added a capability expected in real software: input validation, automated tests, database storage, search, pagination, file imports, scheduled tasks, caching, and text processing.

The result demonstrates how I approach engineering work:

• I break a larger system into manageable, clearly defined increments.
• I write the first solution myself to understand the underlying mechanics.
• I test behavior and handle invalid or incomplete data deliberately.
• I structure code so that new features can be added without rewriting the whole application.
• I document both the result and the lessons learned.

All ten stages are complete. ✅

The application in plain language

The application records activities such as running, swimming, cycling, badminton, strength training, and rest days.

It was intentionally built around a familiar topic so that the engineering decisions remain easy to see. For example, different activities require different information: a run needs distance and duration, strength training needs a duration, and a rest day needs neither. The application therefore has to understand context, reject incomplete entries, and handle optional information safely.

By the final stage, a user can:

• add and view workouts;
• receive clear feedback when information is missing or invalid;
• search, filter, and browse larger sets of results;
• import several workouts from a CSV file;
• enter a workout as ordinary text for the application to interpret;
• rely on automated tests to verify that the system behaves correctly.

Behind the scenes, workouts are stored in a database, repeated requests are served efficiently through caching, and scheduled jobs can run without a user having to trigger them.

Why I built it

My goal was not simply to produce another finished application. I wanted to consolidate the foundations behind reliable backend systems by implementing each capability from scratch and understanding how the parts work together.

Every stage has its own folder and documentation. The notes include what I learned, what caused difficulty, and which decisions I deliberately postponed. This makes the repository both a working codebase and a transparent record of my engineering process.

Architecture

The application separates responsibilities into clear layers:

1. A user or another application sends a request.
2. The Flask API receives it, checks the input, and returns a response.
3. Reusable application logic handles searching, importing, scheduling, caching, and text extraction.
4. A dedicated data-access layer manages all communication with the SQLite database.
5. Automated tests check the complete API behavior.

This separation matters because each part can evolve independently. For example, a scheduled job can reuse the same database functions as the API without duplicating storage logic.

Ten stages, one growing application

Stage	Capability added	Why it matters in a real product	Engineering focus
01 — REST API	Add and retrieve workouts	Allows a website, mobile app, or other system to exchange data with the application	Flask, HTTP, JSON
02 — Validation & Error Handling	Check input and return clear errors	Protects data quality and gives users useful feedback	Validation rules, error responses
03 — Automated API Tests	Verify expected and unexpected behavior	Reduces the risk that future changes break existing features	pytest, fixtures, test client
04 — Database Storage	Save workouts permanently	Keeps information available after the application restarts	SQLite, SQL, data-access layer
05 — Search & Filtering	Find workouts by relevant criteria	Helps users retrieve useful records from growing datasets	Query parameters, dynamic queries
06 — Pagination	Return large result sets in smaller pages	Keeps responses manageable and efficient	Result limits, offsets, metadata
07 — CSV File Import	Import multiple workouts together	Replaces repetitive manual entry and supports existing data	File uploads, CSV processing
08 — Scheduled Background Jobs	Run recurring work automatically	Supports tasks that should happen without a user request	Scheduling, background processing
09 — Caching	Reuse frequently requested results	Improves response speed and reduces unnecessary database work	Cache strategy, invalidation
10 — Text Parsing	Turn ordinary text into structured workouts	Makes data entry faster and more natural	Regular expressions, information extraction

Technical overview

The project uses Python 3.12, Flask, SQLite, pytest, and APScheduler. Most functionality relies on Python's standard library, including CSV processing and regular expressions. Dependencies were introduced only when a stage genuinely required them.

From stage 04 onward, the database code lives in a dedicated db.py data-access layer. Flask routes manage web requests, while db.py manages storage. This keeps responsibilities clear and allows features such as background jobs to reuse the same database operations.

Run the project

Python 3.12 or newer is required.

git clone https://github.com/ajitagupta/python-engineering-lab.git
cd python-engineering-lab
python -m venv .venv
.venv\Scripts\activate          # macOS/Linux: source .venv/bin/activate

Each numbered folder contains its own README with dependencies and run instructions. Reading the folders in order shows how the application evolved from a basic endpoint into a small but complete backend system.

---

A completed learning-in-public project: ten carefully understood engineering concepts, combined into one working application.