Chapter 58: Building Your Portfolio and Getting Hired
You've spent 57 chapters learning Python. Now you need to show the world what you can do.
The truth is this: employers don't care what courses you took. They care what you've built. A portfolio of three strong, well-documented projects will open more doors than a dozen certifications.
This chapter tells you exactly what to build, how to present it, how to write a Python-focused resume, and how to answer the most common interview questions.
What Makes a Python Portfolio Stand Out
Most beginner portfolios look the same: a to-do list, a calculator, a weather app. Hiring managers have seen them a thousand times.
A strong portfolio is different in three ways:
- Solves a real problem — even a small, personal one
- Shows the full stack — not just the code, but tests, docs, CI, clean structure
- Is easy to run — a hiring manager should be able to clone it and run it in under two minutes
Five Project Ideas (With Difficulty Levels)
1. Personal Finance Tracker API [][]
Build a REST API with FastAPI that tracks income, expenses, and budgets. Store data in SQLite with SQLAlchemy. Add JWT authentication. Write a full pytest test suite.
Technologies: FastAPI, SQLAlchemy, Pydantic, JWT, pytest
What it shows: API design, database ORM, auth, testing
GET /transactions <- with filtering by date/category
POST /transactions
GET /summary/monthly <- grouped by category
GET /summary/trends <- monthly spending over time
2. Web Scraper + Data Dashboard [][][*]
Scrape a real website (job listings, property prices, sports stats), clean the data with pandas, store it in SQLite, and build a dashboard with Streamlit or Plotly Dash.
Technologies: requests, BeautifulSoup, pandas, SQLite, Streamlit
What it shows: data pipeline skills, visualisation, automation
# Streamlit dashboard in ~50 lines
import streamlit as st
import pandas as pd
st.title("Job Market Tracker")
df = pd.read_sql("SELECT * FROM jobs", conn)
st.metric("Total Jobs", len(df))
st.bar_chart(df.groupby("category").size())
st.dataframe(df.sort_values("date_posted", ascending=False).head(20))
3. CLI Tool for Developer Productivity [][]
Build a command-line tool that solves a real developer problem: a note-taking CLI, a git log formatter, a .env file manager, a snippet manager. Publish it to PyPI.
Technologies: typer, rich, pathlib, sqlite3, setuptools
What it shows: CLI design, packaging, real-world utility
This is highly impressive because it's a tool other developers might actually use. A PyPI package proves you can ship.
4. Machine Learning Pipeline [][][*]
Pick a public dataset (Kaggle, UCI, or scrape your own), build a complete ML pipeline: clean data, engineer features, train multiple models, evaluate, and serve predictions via a FastAPI endpoint.
Technologies: pandas, scikit-learn, FastAPI, Docker
What it shows: end-to-end ML, model serving, engineering skills
# Serve your model as an API
from fastapi import FastAPI
from pydantic import BaseModel
import joblib
app = FastAPI()
model = joblib.load("model.pkl")
class PredictionRequest(BaseModel):
features: list[float]
@app.post("/predict")
def predict(req: PredictionRequest):
prediction = model.predict([req.features])
return {"prediction": float(prediction[0])}
5. Full-Stack Web App [][][][]
Build something you would actually use: a recipe manager, a reading tracker, a workout log, a budget app with charts. FastAPI or Django backend + a simple HTML/CSS frontend or a React frontend.
Technologies: FastAPI/Django, SQLAlchemy, JWT, HTML/CSS or React
What it shows: full product thinking, frontend + backend integration, deployment
Deploy it live on Render or Railway so it has a real URL.
How to Document Your Projects on GitHub
A great GitHub project has all of these:
1. A compelling README
# Finance Tracker API
> A personal finance API with automatic categorisation,
> monthly summaries, and trend analysis.
[]()
[]()
## Live Demo
API: https://finance-api.onrender.com/docs
## Features
- [lock] JWT authentication
- [chart] Monthly spending summaries
- [tag] Automatic category detection
- [trend] Trend analysis over time
- [x] 95% test coverage
## Quick Start
```bash
git clone https://github.com/you/finance-api
cd finance-api
cp .env.example .env
pip install -e ".[dev]"
pytest # all tests pass
uvicorn app.main:app --reload
Architecture
src/
├── api/ <- FastAPI routes
├── services/ <- business logic
├── models/ <- SQLAlchemy ORM
├── schemas/ <- Pydantic schemas
└── tests/ <- 50+ tests
Tech Stack
Python 3.12 · FastAPI · SQLAlchemy · Pydantic · pytest · Docker
### 2. Working CI badge
Your README should show a green CI badge. It proves the code actually works — not just on your machine.
### 3. Tests with coverage
Run `pytest --cov` and include the output or a Codecov badge in the README. Even 70% coverage is far better than no tests.
### 4. Live deployment URL
If it's a web app or API, deploy it. Free tiers on Render, Railway, and Fly.io are enough for a portfolio project.
### 5. Clean git history
Use conventional commits. Hiring managers sometimes look at the commit log. Small, logical commits tell a story of how you solved the problem.
## Writing a Python-Focused Resume
Your resume has one job: get you an interview. Here's what works:
### Lead with what you can do
Python Developer | 2 years | FastAPI · SQLAlchemy · pandas · pytest
Not "Python enthusiast" or "aspiring developer." State what you are.
### Show numbers where you can
- "Built a REST API serving 500 requests/day"
- "Reduced data processing time by 60% with vectorised NumPy operations"
- "Maintained 94% test coverage across 1,200 lines of production code"
### List projects, not tutorials
Finance Tracker API github.com/you/finance-api FastAPI · SQLAlchemy · JWT · pytest · Docker render.com/finance-api
- REST API with JWT auth, 50+ test cases, deployed on Render
- Implemented automatic category detection using keyword matching
- Achieved 95% code coverage with pytest-cov
### Skills section — be specific
Languages: Python 3.11/3.12 Web: FastAPI, Flask, SQLAlchemy, Pydantic, JWT Data: pandas, NumPy, matplotlib, seaborn, scikit-learn Tools: pytest, ruff, mypy, Docker, Git, GitHub Actions Databases: PostgreSQL, SQLite, Redis Cloud: AWS (S3, Lambda), Render
Don't list "Python" by itself. List what you've done with it.
## Common Python Interview Questions
### Fundamentals
**Q: What is the difference between a list and a tuple?**
Lists are mutable (you can change them after creation). Tuples are immutable. Use tuples for data that should not change — coordinates, RGB values, function return pairs. Tuples are also slightly faster and can be used as dictionary keys.
**Q: What is a decorator?**
A decorator is a function that takes a function and returns a modified version. The `@` syntax is shorthand: `@timer` is equivalent to `func = timer(func)`. Common uses: timing, logging, caching (`@lru_cache`), access control.
**Q: What is the GIL?**
The Global Interpreter Lock is a mutex inside CPython that allows only one thread to execute Python bytecode at a time. It simplifies memory management (reference counting is not thread-safe without it). For I/O-bound work, threads still help because the GIL is released during I/O. For CPU-bound work, use `multiprocessing` or PyPy.
**Q: What is the difference between `is` and `==`?**
`==` tests value equality. `is` tests identity — whether two variables point to the same object in memory. Use `==` for value comparisons. Use `is` only for `None`, `True`, `False`.
```python
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b) # True — same value
print(a is b) # False — different objects
Q: Explain list comprehensions vs generator expressions.
List comprehensions ([x*2 for x in range(10)]) evaluate eagerly — they create the whole list in memory at once. Generator expressions ((x*2 for x in range(10))) evaluate lazily — they produce one item at a time. Use generators when the sequence is large or when you only iterate once.
Intermediate
Q: What is a context manager?
An object that defines __enter__ and __exit__ methods, used with the with statement. __enter__ sets up the resource, __exit__ tears it down — even if an exception occurs. File handling (with open(...)) is the classic example.
Q: Explain *args and **kwargs.
*args collects extra positional arguments into a tuple. **kwargs collects extra keyword arguments into a dictionary. They allow functions to accept any number of arguments:
def log(message, *args, **kwargs):
print(message.format(*args), kwargs)
Q: What is the difference between @staticmethod and @classmethod?
@classmethod receives the class (cls) as first argument and can create instances or access class state. @staticmethod receives no implicit argument — it's just a function namespaced inside the class with no access to class or instance state.
Q: How does Python's memory management work?
Python uses reference counting as the primary mechanism — each object tracks how many references point to it; when the count reaches 0, the object is freed immediately. For reference cycles (A -> B -> A), Python runs a cyclic garbage collector periodically.
Advanced
Q: What is the difference between __getattr__ and __getattribute__?
__getattribute__ is called on every attribute access. __getattr__ is called only when normal attribute lookup fails. Override __getattr__ for proxy objects or dynamic attributes. Override __getattribute__ only when you need to intercept every access — be careful of infinite recursion.
Q: Explain Python's descriptor protocol.
A descriptor is any object that defines __get__, __set__, or __delete__. When you access an attribute, Python checks if the class attribute is a descriptor and calls its __get__ method. property, classmethod, and staticmethod are all descriptors.
Q: How does async/await work?
async def defines a coroutine — a function that can suspend its execution. await suspends the coroutine until the awaited coroutine completes, handing control back to the event loop so other coroutines can run. The event loop (asyncio.run()) manages all running coroutines. This is cooperative multitasking — coroutines voluntarily yield control, unlike threads which are pre-empted by the OS.
Q: What does __slots__ do?
__slots__ replaces the per-instance __dict__ with fixed-size attribute slots. This reduces memory usage by ~200 bytes per instance and slightly speeds up attribute access. Use it for classes with millions of instances.
Coding Challenges — Practice Platforms
| Platform | Best for |
|---|---|
| LeetCode | Algorithmic problems (FAANG interviews) |
| HackerRank | General coding + domain-specific (SQL, data) |
| Codewars | Fun kata-style problems, good for practice |
| Exercism | Mentored Python track |
| Advent of Code | Annual December challenge — builds problem-solving |
| Project Euler | Mathematical programming problems |
For most Python jobs (outside FAANG), you'll solve problems like:
- Parse a CSV and compute statistics
- Write a function that does X with a list
- Fix a bug in this code
- Design a class hierarchy for this scenario
You don't need to master dynamic programming to get a Python developer job. Focus on clean code, good tests, and clear communication.
Open Source Contributions
Contributing to open source is one of the best ways to get noticed:
- Pick a library you use — you already understand the domain
- Start small — fix a typo in the docs, improve an error message, add a missing test
- Read the contributing guide — every project has one
- Find good first issues — filter by
good first issuelabel on GitHub
Your first contribution doesn't have to be a new feature. A well-written bug fix with tests is impressive.
The Job Search Strategy
- Build 2-3 strong projects — quality over quantity
- Deploy them live — a URL you can click is worth ten screenshots
- Write about your projects — a short blog post on Dev.to or your GitHub README explaining what you built and why
- LinkedIn — update your headline to "Python Developer | FastAPI · pandas · pytest" and add your projects
- Apply early — respond within 24 hours of postings
- Network — attend Python meetups (meetup.com), PyCon, and local user groups
- Practice interviews — solve 2-3 LeetCode easy/medium problems per week for 4-6 weeks before actively applying
What You Learned in This Chapter
- Employers care about what you've built, not what you studied. Three strong projects outperform ten certificates.
- Strong portfolio projects solve real problems, show the full engineering stack (tests, docs, CI, deployment), and are easy to run.
- Five project ideas ranked by difficulty: Finance API, Web Scraper Dashboard, CLI Tool (publish to PyPI), ML Pipeline, Full-Stack App.
- A great GitHub project has: a compelling README with badges, working CI, test coverage, a live URL, and a clean commit history.
- Resume tips: lead with skills not attitude, show numbers, list projects not tutorials, be specific in the skills section.
- Key interview questions covered: GIL,
isvs==, generators vs lists, decorators, context managers,*args/**kwargs, descriptors, async/await,__slots__. - Practice on LeetCode/Codewars/Exercism. For most Python jobs, clean code and good tests matter more than algorithmic complexity.
- Open source contributions — even small ones — are highly valued by employers.
What's Next?
Chapter 59 — the final chapter — covers Keep Learning: Resources and Community. Where to go from here, the best books and podcasts, the communities worth joining, and a personal learning roadmap for the next 12 months.