This application evolved from a terminal-based flashcard learning tool into a fully deployed, session-driven Flask web application.

The goal was not only to implement learning logic —
but to build a structured, production-ready backend system with real-world deployment considerations.

Core features:

• User authentication with hashed passwords
• Expiration-based access control
• Weighted random card selection (adaptive repetition logic)
• Persistent per-user progress stored server-side
• Clean separation between game engine, persistence layer and web interface
• Session-managed state across requests
• Deployment using Flask, Passenger and isolated virtual environments
• Integration alongside an existing WordPress installation without routing conflicts

The application architecture separates:

• Core game logic (engine)
• Authentication utilities
• Save state management
• Web routing layer
• Static UI layer

This project reflects my approach to backend development:
design first, structure second, deployment third — polish last.

View source code on

This mini project was originally developed as part of my Python loop and input-validation practice.

As an extra challenge — and because I enjoy experimenting beyond assignment requirements — I decided to transform the original terminal-based exercise into a fully deployable web application.

The goal was not only to recreate the game logic in a browser environment,
but also to demonstrate:

• Server-side validation (odd-number round enforcement)
• Session-based state management
• Controlled error handling
• Production deployment using Flask, Passenger, and virtual environments
• Integration alongside an existing WordPress site

The game intentionally preserves the structure of the original assignment.
It is designed for two human players rather than a CPU opponent,
and it keeps certain UI characteristics aligned with the original console-based logic.

This project reflects my approach to learning:
not just completing exercises — but extending them into real-world, deployable solutions.

View source code on

This project was originally developed as part of my Python practice on:

• nested loops
• list-of-lists matrix manipulation
• structured input validation
• state tracking across multiple steps

As an extension challenge, I redesigned the original console-based ticket booking system into a fully deployable Flask web application.

The goal was not only to reproduce the booking logic in a browser environment,
but to demonstrate:

• Multi-phase application flow (movie → ticket count → seat selection → summary)
• Session-based state management across requests
• Matrix-based seat representation and validation logic
• Controlled error handling and user feedback
• Clean separation between rendering logic and state updates
• Production deployment using Flask, Passenger, and virtual environments
• Integration alongside an existing WordPress site

The application intentionally preserves the structured, step-by-step logic of the original CLI version, while adapting the interface into a styled terminal-like browser experience.

This project reflects my approach to learning:

not just solving exercises — but transforming them into structured, deployable applications that demonstrate both backend logic and real-world integration.

The seating system is implemented as a 2D matrix model,
where each seat state (available, booked, selected, purchased) is explicitly represented and validated server-side.

The UI dynamically reflects backend state changes without relying on client-side frameworks, keeping the logic clean and Python-focused.

View source code on