Software Engineer — Competency Roadmap

You'll learn

• Python Interpreter — the program that reads and executes Python code
• VS Code — a lightweight, extensible source-code editor
• Terminal Execution — running programs via command line interfaces

How to work through it

1. 1Download and install Python 3.12 or newer
2. 2Install Visual Studio Code and the official Python extension
3. 3Create a directory named `workspace` on your machine
4. 4Write a script named `verify_env.py` printing the Python version and current time
5. 5Execute the script via the command line

You'll learn

• Data Collections — lists, tuples, dictionaries, and sets in Python
• File I/O — reading and writing structured data to disk
• Exception Handling — using try-except blocks to catch runtime errors

How to work through it

1. 1Define data structures using lists and dictionaries to represent expenses
2. 2Implement helper functions for input validation and calculations
3. 3Implement read and write operations using Python's `json` module
4. 4Build an interactive menu loop supporting add, list, filter, and delete operations
5. 5Handle common exceptions such as missing files or malformed entries

You'll learn

• Modular Programming — splitting logic across distinct Python files
• State Management — tracking and updating mutating program state
• Game Loop Pattern — continuous execution cycles responding to inputs

How to work through it

1. 1Draft the game state schema including player attributes and game map
2. 2Separate game logic, display helpers, and state storage into distinct Python modules
3. 3Implement the core game evaluation loop
4. 4Add automated input simulation to test win and loss conditions
5. 5Record a five-minute demonstration walk-through of the code and gameplay

You'll learn

• Standard Streams — stdin, stdout, and stderr data pipelines
• Shell Scripting — automating multi-step command sequences
• POSIX Permissions — read, write, and execute bits on Unix filesystems

How to work through it

1. 1Practice core commands: `ls`, `cd`, `mkdir`, `rm`, `cp`, `mv`
2. 2Learn stream redirection using `>`, `>>`, and pipes `|`
3. 3Filter text streams using `grep`, `awk`, and `sed`
4. 4Write a shell script containing conditional checks and loop constructs
5. 5Make the script executable with `chmod +x` and run it

You'll learn

• Git Object Model — blobs, trees, commits, and refs
• Branching Strategies — isolating feature development from mainline branches
• Merge Conflicts — identifying and resolving conflicting textual diffs

How to work through it

1. 1Configure global Git credentials (`user.name`, `user.email`)
2. 2Initialize a repository and stage changes with atomic commits
3. 3Create feature branches and merge them using both fast-forward and merge commits
4. 4Deliberately introduce and resolve a merge conflict between two branches
5. 5Push the repository to GitHub and create a Pull Request with markdown documentation

You'll learn

• Pre-commit Hooks — scripts that run automatically before a commit is recorded
• Semantic Versioning — major.minor.patch version numbering standards
• Open Source Standards — licenses, issue templates, and documentation

How to work through it

1. 1Configure a strict `.gitignore` for Python and common operating system files
2. 2Write a comprehensive `README.md` following standard open-source conventions
3. 3Install and configure `pre-commit` to run automated code formatting
4. 4Verify that malformed commits are automatically intercepted and fixed
5. 5Tag a `v1.0.0` release on GitHub

You'll learn

• Asymptotic Analysis — measuring algorithm resource usage relative to input size
• Space Complexity — total memory overhead allocated during execution
• Binary Search — logarithmic time search on sorted collections

How to work through it

1. 1Study definitions for $O(1)$, $O(\log n)$, $O(n)$, $O(n \log n)$, and $O(n^2)$
2. 2Analyze single loops, nested loops, and recursive calls for time complexity
3. 3Identify auxiliary memory allocation to evaluate space complexity
4. 4Document edge cases where worst-case and average-case diverge
5. 5Review solutions against theoretical bounds

You'll learn

• Nodes and References — manual memory linking between independent objects
• Stack (LIFO) — Last-In First-Out structure for recursion and undo systems
• Queue (FIFO) — First-In First-Out structure for job queues and buffering

How to work through it

1. 1Define a `Node` class storing values and reference pointers
2. 2Implement singly linked list methods: `append`, `prepend`, `delete_value`, `find`
3. 3Implement a doubly linked list with forward and backward traversal
4. 4Implement stack and queue interfaces with $O(1)$ push/pop/enqueue/dequeue operations
5. 5Write comprehensive assertions covering all edge operations

You'll learn

• Hash Functions — deterministic mapping of arbitrary keys to integer indices
• Collision Resolution — chaining vs open addressing strategies
• Amortized Complexity — average performance over a sequence of resizing operations

How to work through it

1. 1Implement a hash code generator and modulo bucket-mapping index function
2. 2Implement key-value pair insertion and collision resolution via linked bucket chains
3. 3Implement lookup (`get`) and deletion (`remove`) operations with key-equality checks
4. 4Calculate load factor and implement dynamic table doubling and re-hashing
5. 5Benchmark lookup times against Python's native `dict`

You'll learn

• Binary Search Tree — ordered binary tree enabling logarithmic searches
• Graph Traversal — systematic node exploration using BFS and DFS
• Cycle Detection — identifying loops in directed and undirected graphs

How to work through it

1. 1Create a `TreeNode` class and BST insertion/search methods
2. 2Write recursive in-order, pre-order, and post-order traversal functions
3. 3Construct a `Graph` class backed by an adjacency list dictionary
4. 4Implement iterative BFS using a queue to find shortest paths
5. 5Implement DFS using recursion and an explicit visited set to detect cycles

You'll learn

• Bitwise Operations — direct manipulation of individual bits in memory
• Memory Hierarchy — speed vs capacity trade-offs from CPU registers to disk storage
• Instruction Cycle — fetch, decode, and execute loop of modern processors

How to work through it

1. 1Study number systems: binary, octal, decimal, and hexadecimal conversions
2. 2Learn bitwise operators: `&`, `|`, `^`, `~`, `<<`, `>>`
3. 3Review CPU architecture: registers, program counter, and instruction pipeline
4. 4Map out the memory hierarchy latency numbers (nanoseconds to milliseconds)
5. 5Build a bitmask simulator that toggles permission flags within an 8-bit integer

You'll learn

• Pointers & Heap — direct memory addresses and dynamic runtime allocation
• Stack vs Heap — automatic call stack frames vs dynamic heap allocations
• Process Forking — OS kernel duplicating process execution contexts

How to work through it

1. 1Install `gcc` or `clang` and write a basic `main.c` program
2. 2Demonstrate pointer arithmetic and address-of (`&`) / dereference (`*`) operators
3. 3Allocate an array dynamically with `malloc()` and release it with `free()`
4. 4Use `fork()` to spawn a child process and synchronize termination with `wait()`
5. 5Inspect memory allocations with address sanitizers

You'll learn

• Race Conditions — non-deterministic bugs caused by unsynchronized concurrent access
• Mutex / Locks — mutual exclusion mechanisms to protect critical sections
• Deadlocks — conditions where multiple threads block indefinitely waiting for resources

How to work through it

1. 1Demonstrate a data race condition by mutating a shared variable across threads without locks
2. 2Introduce a Mutex (`threading.Lock`) to serialize access to the critical section
3. 3Implement a Producer-Consumer pattern using a synchronized queue
4. 4Handle thread shutdown signals cleanly
5. 5Benchmark throughput differences between single-threaded and multi-threaded runs

You'll learn

• TCP vs UDP — trade-offs between reliability/ordering and speed
• DNS Resolution — hierarchical domain name translation to IP addresses
• TLS Handshake — cryptographic protocol securing encrypted HTTPS communication

How to work through it

1. 1Learn IP addressing, subnetting, and packet routing fundamentals
2. 2Compare TCP (connection-oriented, reliable) vs UDP (connectionless, fast)
3. 3Trace a DNS lookup using CLI tools (`dig`, `nslookup`, `traceroute`)
4. 4Diagram the TCP 3-way handshake (SYN, SYN-ACK, ACK) and connection teardown
5. 5Document the complete request lifecycle from browser keypress to page render

You'll learn

• Socket API — operating system interface for network communication endpoints
• Packet Framing — delimiting byte streams into discrete application messages
• I/O Multiplexing — handling hundreds of network connections with `select` or `epoll`

How to work through it

1. 1Create a TCP socket, bind it to an IP and port, and listen for connections
2. 2Handle multiple incoming connections using non-blocking I/O (`select`) or threading
3. 3Implement a message protocol framing text into delimited byte packets
4. 4Broadcast received messages to all other connected client sockets
5. 5Test abnormal disconnections and close socket file descriptors cleanly

You'll learn

• HTTP Protocol — stateless client-server application layer protocol
• MIME Types — header-specified media formatting for web assets
• HTTP Status Codes — standard response groups: 2xx (Success), 4xx (Client), 5xx (Server)

How to work through it

1. 1Parse the HTTP request line (Method, URI, Protocol Version)
2. 2Parse key-value HTTP headers and handle Content-Length for request bodies
3. 3Implement file system reading to serve static HTML and CSS files with correct MIME types
4. 4Format RFC-compliant HTTP response strings including status codes and headers
5. 5Test the server using `curl -v` to inspect exact request and response headers

You'll learn

• Database Normalization — organizing relational fields to minimize data redundancy
• Foreign Key Constraints — database-enforced relational integrity rules
• SQL Migrations — version-controlled scripts describing schema alterations

How to work through it

1. 1Install PostgreSQL locally and connect via `psql` or a graphical client like DBeaver
2. 2Design tables: `users`, `products`, `orders`, and `order_items`
3. 3Apply constraints: `PRIMARY KEY`, `FOREIGN KEY`, `NOT NULL`, and `UNIQUE`
4. 4Enforce referential integrity using `ON DELETE CASCADE` or `RESTRICT` rules
5. 5Write a repeatable `.sql` migration script that builds and seeds the schema

You'll learn

• SQL Joins — combining rows from two or more tables based on related columns
• Window Functions — performing calculations across a set of table rows related to the current row
• Common Table Expressions — temporary named result sets for structuring complex queries

How to work through it

1. 1Write multi-table `INNER JOIN` and `LEFT JOIN` queries
2. 2Group records with `GROUP BY` and filter aggregated groups with `HAVING`
3. 3Write Common Table Expressions (CTEs) using `WITH` statements for readability
4. 4Implement window functions using `OVER (PARTITION BY ... ORDER BY ...)`
5. 5Verify query results against known seed data calculations

You'll learn

• B-Tree Indexing — balanced tree data structures enabling $O(\log n)$ disk lookups
• Query Planner — database engine component that determines optimal execution strategies
• Sequential vs Index Scan — full table scans versus indexed pointer lookups

How to work through it

1. 1Generate 100,000 synthetic records using SQL `generate_series()`
2. 2Run a filtering query without indexes and record execution time with `EXPLAIN ANALYZE`
3. 3Analyze the output: cost estimates, execution time, and scan types (Seq Scan vs Index Scan)
4. 4Create single-column and composite B-Tree indexes
5. 5Re-run `EXPLAIN ANALYZE` and document the query planner's optimization

You'll learn

• ACID Guarantees — database reliability guarantees under concurrent execution and failures
• Transaction Isolation Levels — Read Committed, Repeatable Read, Serializable
• Pessimistic Locking — locking rows explicitly to prevent concurrent mutations

How to work through it

1. 1Review ACID properties: Atomicity, Consistency, Isolation, and Durability
2. 2Write a funds transfer script wrapped in an explicit transaction block
3. 3Simulate an error mid-transaction and verify that all operations are rolled back completely
4. 4Simulate concurrent debit attempts using Python threads or multiple terminal sessions
5. 5Apply row-level locking (`FOR UPDATE`) to serialize access to balance rows

You'll learn

• SOLID Principles — fundamental guidelines for maintainable object-oriented software
• Dependency Injection — passing dependencies into objects rather than hardcoding them
• Strategy Pattern — behavioral pattern enabling algorithms to be selected at runtime

How to work through it

1. 1Identify tightly coupled dependencies and responsibilities in a legacy codebase
2. 2Extract distinct responsibilities into dedicated classes and modules
3. 3Implement the Strategy Pattern to swap algorithms or behaviors at runtime
4. 4Use Dependency Injection to pass database or service clients into consumers
5. 5Verify that adding a new feature requires no modifications to existing core classes

You'll learn

• Unit vs Integration Testing — testing isolated logic units versus coordinated subsystems
• Test Fixtures — standardized, repeatable context environments for running test suites
• Mocking & Stubbing — replacing external services with deterministic test doubles

How to work through it

1. 1Install `pytest`, `pytest-cov`, and `pytest-mock`
2. 2Write unit tests with explicit assertions checking expected outputs and raised exceptions
3. 3Use `@pytest.mark.parametrize` to test multiple inputs and boundary conditions in one test
4. 4Create reusable test fixtures with setup and teardown phases
5. 5Mock external network API requests using `unittest.mock`
6. 6Generate an HTML coverage report and inspect untested code branches

You'll learn

• Continuous Integration — automated building, testing, and linting of shared code
• GitHub Actions — workflow automation directly integrated into GitHub repositories
• Build Matrix — executing CI jobs concurrently across multiple runtime environments

How to work through it

1. 1Create `.github/workflows/ci.yml` in your repository
2. 2Configure triggers for `push` and `pull_request` on the `main` branch
3. 3Define job steps: checkout code, set up Python environment, install dependencies
4. 4Add linting and formatting steps using `ruff` and `black`
5. 5Execute `pytest` with coverage reporting and enforce a zero-failure exit code

You'll learn

• REST Architecture — Representational State Transfer constraints and HTTP verb semantics
• Pydantic Validation — runtime data parsing, type enforcement, and serialization
• ORM (Object-Relational Mapping) — mapping database rows directly to application objects

How to work through it

1. 1Install FastAPI, Uvicorn, and SQLAlchemy
2. 2Define Pydantic request and response validation schemas
3. 3Implement ORM database models mapping to PostgreSQL tables
4. 4Build CRUD route handlers with path parameters, query parameters, and request bodies
5. 5Verify interactive API documentation automatically generated at `/docs`

You'll learn

• Password Hashing — one-way cryptographic salting and hashing algorithms
• JSON Web Tokens (JWT) — stateless signed tokens for client authentication
• Role-Based Access Control (RBAC) — restricting resource access based on assigned user roles

How to work through it

1. 1Hash user passwords using `passlib` / `bcrypt` before database storage
2. 2Build a `/login` endpoint that validates credentials and issues signed JWT tokens
3. 3Create a FastAPI dependency to decode and validate JWT tokens from Authorization headers
4. 4Attach user identity to the request context
5. 5Implement role-based authorization checks (e.g., admin vs regular user)

You'll learn

• Docker Images & Containers — lightweight, isolated execution packages for applications
• Docker Compose — tool for defining and running multi-container Docker environments
• Multi-stage Builds — optimizing container image size and separating build from runtime

How to work through it

1. 1Write a `.dockerignore` file excluding virtual environments and cache files
2. 2Write a multi-stage `Dockerfile` minimizing final image size and running as a non-root user
3. 3Create a `docker-compose.yml` linking the API service and PostgreSQL container
4. 4Configure Docker named volumes to persist database storage across container restarts
5. 5Test container networking and verify healthcheck configurations

You'll learn

• In-Memory Data Store — ultra-fast sub-millisecond RAM-based key-value storage
• Cache-Aside Pattern — application reads from cache first, populating on miss
• Cache Invalidation — strategies for keeping cached data consistent with the source of truth

How to work through it

1. 1Add a Redis container to your Docker Compose environment
2. 2Implement the Cache-Aside pattern with explicit Time-To-Live (TTL) expiration
3. 3Implement cache invalidation logic upon data updates or deletions
4. 4Build a rate-limiting middleware using Redis atomic counters (`INCR`, `EXPIRE`)
5. 5Measure latency improvements using `curl` or a benchmarking tool like `wrk`

You'll learn

• Message Broker — intermediary system translating and routing messages between services
• Asynchronous Task Processing — offloading heavy computational workloads from web servers
• Dead Letter Queue — holding failed messages for inspection and retries

How to work through it

1. 1Configure RabbitMQ or Redis as a message broker in Docker Compose
2. 2Set up Celery or an async task worker script to consume jobs from a queue
3. 3Create API endpoints to dispatch background jobs and return a tracking UUID
4. 4Implement worker task logic with retry policies and dead-letter handling
5. 5Build a status endpoint allowing clients to poll job progress

You'll learn

• Cloud Infrastructure — compute, storage, and networking services hosted off-premises
• Secret Management — securing API keys and database credentials in production environments
• Production Health Checks — automated probes checking container readiness and liveness

How to work through it

1. 1Provision a cloud server or container service instance
2. 2Provision a managed cloud PostgreSQL database instance
3. 3Configure secure production environment variables and secrets
4. 4Deploy the Docker container image to the cloud host
5. 5Verify automated TLS encryption and live endpoint functionality

You'll learn

• Component Lifecycle & Virtual DOM — UI rendering and reactive state updates
• TypeScript — static type checking for JavaScript applications
• SPA Routing — handling client-side navigation without page reloads

How to work through it

1. 1Scaffold a modern frontend project with Vite and TypeScript
2. 2Build UI components with modular props and state management (`useState`, `useEffect`)
3. 3Integrate an HTTP client (Axios or Fetch) with authentication token interceptors
4. 4Implement client-side routing and protected routes
5. 5Handle loading spinners, error alerts, and form validation states

You'll learn

• Static Compilation — transforming source code into standalone machine-executable binaries
• Memory Safety Models — Rust's ownership/borrow checker vs Go's garbage collection
• Binary Parsing — reading and interpreting structured raw byte streams directly

How to work through it

1. 1Install Rust (`rustup` / `cargo`) or Go (`go`)
2. 2Learn basic syntax, structs, and error handling patterns (`Result`/`Option` or `error` returns)
3. 3Read raw binary byte buffers from a file on disk
4. 4Parse binary headers, magic numbers, and chunked byte offsets
5. 5Compile an optimized release binary and benchmark execution speed

You'll learn

• RFC Process — Request for Comments methodology for architectural decision-making
• Trade-off Analysis — systematically weighing performance, simplicity, cost, and time
• System Architecture Diagramming — visual communication of system boundaries and components

How to work through it

1. 1Define the problem statement, business goals, and explicit non-goals
2. 2Diagram the proposed architecture and data flow
3. 3Specify database schema alterations and API contract changes
4. 4Analyze alternate approaches and justify why they were rejected
5. 5Document risk mitigation, monitoring strategies, and rollback plans

You'll learn

• Structured Logging — machine-parseable log formatting (JSON) for log aggregators
• Correlation IDs — unique identifiers passed across service boundaries to trace requests
• Application Metrics — counters, gauges, and histograms tracking real-time health

How to work through it

1. 1Replace standard print statements with a structured JSON logging library
2. 2Implement middleware that attaches a unique `X-Request-ID` to all incoming requests and logs
3. 3Instrument route handlers to track HTTP request counts and latency histograms
4. 4Expose an endpoint formatted for Prometheus metrics scraping
5. 5Simulate unhandled exceptions and trace the error using only log output

You'll learn

• Code Review Etiquette — delivering actionable, constructive feedback during peer review
• Blameless Postmortems — analyzing failures to improve systems without assigning personal fault
• Root Cause Analysis — techniques for diagnosing underlying systemic failures

How to work through it

1. 1Review a substantial pull request checking for logic bugs, security risks, and test coverage
2. 2Provide empathetic, actionable feedback with code suggestions
3. 3Simulate a production incident (e.g., database connection pool exhaustion)
4. 4Draft a timeline of detection, response, mitigation, and resolution
5. 5Identify the systemic root cause using the '5 Whys' technique and define preventive action items

You'll learn

• End-to-End System Integration — connecting UI, API, database, cache, and background workers
• Production Deployment — configuring live hosting, DNS, and environment secrets
• Project Presentation — documenting system design and setup clearly for technical reviewers

How to work through it

1. 1Draft a design RFC outlining features, database models, and API endpoints
2. 2Develop backend API endpoints with comprehensive automated test suites
3. 3Build a responsive frontend UI consuming the API endpoints
4. 4Configure Docker containerization and automated GitHub Actions CI pipeline
5. 5Deploy the application to cloud hosting and verify production monitoring

You'll learn

• Pattern Recognition — mapping novel problem statements to known algorithmic paradigms
• Technical Communication — articulating algorithmic trade-offs clearly under timed conditions
• Edge Case Identification — systematically checking boundary limits and potential overflow

How to work through it

1. 1Study pattern recognition across array, string, hash map, and pointer problems
2. 2Practice explaining your thought process out loud before writing code
3. 3Implement brute-force solutions first, then optimize time/space complexity
4. 4Test boundary conditions manually (empty inputs, single elements, duplicates)
5. 5Log problem patterns and review mistaken assumptions

You'll learn

• Market Gap Analysis — mapping personal demonstrable skills against current industry demand
• Portfolio Evaluation — auditing project codebases from the perspective of a hiring manager
• Continuous Professional Development — structuring self-directed learning for long-term career growth

How to work through it

1. 1Gather 10 job descriptions across companies of different sizes (startups, mid-sized, enterprise)
2. 2Extract common technical requirements (languages, frameworks, databases, cloud tools)
3. 3Match your completed projects against each requirement to verify demonstrable proof
4. 4Identify recurring unaddressed technologies (e.g., GraphQL, specific cloud services)
5. 5Formulate a prioritized 3-month continuous learning plan targeting your identified gaps