Public Build Log · Rapid Skills Acceleration
10-Day Python Sprint
Ten consecutive days of Python, built and documented in public - one folder per day, from core runtime and control flow to a working command-line log-analysis tool. The repository preserves the whole learning trail: chronological, incremental commits that show how understanding actually develops.
Every day shipped working code, a GitHub commit, and a technical write-up.
- 10Day projects
- 13Commits
- 100%Python
Overview
Functional competence, fast
This sprint was a deliberate rapid-acceleration exercise, completed in public. The objective was not academic mastery - it was functional competence: the ability to write, run, debug, and refactor Python that resembles real automation, cloud, and systems work.
Over ten consecutive days I committed to building, documenting, and publishing a small Python artifact every day. Early days emphasize mechanics; later days shift toward design decisions and refactoring. The result is a timestamped record of working code - and, just as importantly, a demonstration of disciplined execution and a transparent engineering workflow.
Ground rules
Objectives
- Become genuinely productive with Python quickly.
- Build confidence through execution, not theory.
- Prepare for the PCEP certification as a secondary outcome.
- Create a public, timestamped record of working artifacts.
Day by day
The sprint timeline
Each day is one folder in the repository. Expand a day to see what was built, then jump straight to the code or the original post.
Simple executable scripts that verified a working understanding of literals, variables, and expressions - getting comfortable with how Python actually runs code.
Scripts that encode rules through conditionals, with clear branching logic driven by user input.
A loop-based script that evaluates and prints even numbers, combining iteration with conditional logic.
Functions that accept inputs and return computed results, with scripts that compose functions instead of duplicating logic. Key insight: return values make functions feel connected rather than isolated.
An interactive access checker that accepts a role and environment, determines an access level, tracks the number of checks performed, and exits cleanly with a summary. Correct but deliberately verbose - a baseline built entirely on explicit if / elif conditionals.
Replaced the Day 5 conditional chains with a dictionary-based rules engine - access rules expressed as data and resolved in a single lookup, with normalized input to handle casing and unexpected values. Same behavior, fewer lines, and far easier to extend and reason about.
A batch rules evaluator that applies the existing access logic across a list of requests and produces a summary report aggregating outcomes by type - the move from interactive, one-at-a-time programs to deterministic batch-style execution.
Access Evaluator v4 validates roles and environments before evaluation, normalizes input, and distinguishes invalid input from no-access from a rule match. It emits a consistent JSON schema for every result and appends timestamped, human-readable audit logs. The behavior maps directly to SE work in Terraform, IAM, CI/CD validation, and log analysis. Artifacts: evaluator_v4.py, output.json, log.txt.
A Log Analyzer that streams log lines with a generator, extracts and classifies levels (INFO, WARN, ERROR), records error timestamps, tracks the first and last events seen, and writes a complete summary to summary.json. Memory-efficient streaming, clean functional decomposition, and automation-ready output. Artifacts: analyzer_v1.py, sample.log, summary.json.
A CLI-enhanced Log Analyzer v2 that accepts a log-file path from the command line, offers optional flags (--errors-only, --json, --output), and reuses the Day 9 parsing and summary logic. It produces human-readable console output and optional machine-readable files - a real automation-tooling pattern built on argparse with clean separation between loading, analysis, and CLI orchestration. Artifacts: logcli.py, sample.log, errors_only.log, summary.json.
The daily thread
Follow the build on X
The sprint was posted publicly as it happened. Here’s the whole thread - all ten posts, in order, one click each.
What the sprint built
Skills built
Portfolio impact
Why this matters
This sprint represents much more than learning Python syntax. It demonstrates a repeatable engineering process: define a goal, build daily, publish transparently, iterate continuously, and document the work. The later days already resemble real automation tooling - validation, structured JSON, audit logging, and log analysis - and the same execution discipline now drives larger projects including RoundTable, StoryTime, and this observability-focused portfolio.
Read the whole trail
Every day, every commit, every artifact is public and timestamped in the repository.