Python course ยท Module 12: Final Project

Career Preparation

6 min read ยท
In this lesson5

Congratulations! You have completed Python Safari. You have twelve locations behind you, but a certificate alone has never hired anyone. A recruiter has a few dozen seconds for your CV, and a technical interview will include questions that check whether you understand what you write. Now it is time to turn your skills into a first job. We will prepare a CV, a LinkedIn profile, answers to typical questions and a list of places worth searching for offers.

CV for a Python Developer

A good developer CV is short and concrete: contact details with a link to GitHub, a one-sentence summary, skills grouped into categories and projects with results. Here is a template:

# John Smith
Python Developer | AI/ML Specialist

john@example.com | linkedin.com/in/john | github.com/john

## Summary
Python developer with experience in building AI/ML applications.
Specialization: RAG systems, FastAPI, Machine Learning.

## Skills

**Languages:** Python, JavaScript, SQL
**Frameworks:** FastAPI, Django, React
**AI/ML:** LlamaIndex, LangChain, PyTorch, scikit-learn
**Databases:** PostgreSQL, Qdrant, Redis
**Tools:** Docker, Git, GitHub Actions, AWS

## Projects

### AI Document Assistant | [GitHub](link) | [Demo](link)
- RAG system for searching documents
- Tech: FastAPI, LlamaIndex, Qdrant, OpenAI
- Results: <2s response time, 92% accuracy

### ML Pipeline | [GitHub](link)
- End-to-end ML pipeline with MLflow
- Tech: scikit-learn, XGBoost, MLflow, Docker
- Results: 15% improvement in accuracy

## Education

**Python Safari** - CodeWorlds (2024)
- 12-module Python and AI course
- Capstone: AI Document Assistant

## Certifications
- [Certificate name]

The Projects section matters more than Education, because it shows what you have built. The numbers in the "Results" fields show the format, they are not ready values: enter only what you really measured in your project. A recruiter may ask about any number in the interview. Early in your career, keep the CV to one page and send it as a PDF so the formatting does not fall apart on the other side.

LinkedIn Optimization

LinkedIn works like a search engine, recruiters search by keywords in the headline and the About section. The headline is not just a job title, it is a list of technologies:

## Headline
Python Developer | AI/ML | FastAPI | Building intelligent applications

## About
Passionate Python developer specializing in AI applications.

RAG Systems & LLM Integration
FastAPI & Async Python
Machine Learning Pipelines

Currently building: AI Document Assistant - semantic search for documents.

Open to opportunities in AI/ML development.

## Featured
- Link to your best project
- An article/post about technology
- A certificate/diploma

The Featured section is the place for a link to your best project. One well-described project with a demo says more than a list of twenty technologies. Also add a link to GitHub in your contact details, because that is exactly where a recruiter will go looking for proof of your skills.

Interview Preparation

A technical interview for a Python developer usually covers four areas. Let's go through them one by one. The first is language fundamentals, and the classic question is about the GIL:

# Typical technical questions

# 1. Python fundamentals
def explain_gil():
    """
    GIL (Global Interpreter Lock) - a mechanism in CPython
    that allows only one thread to execute
    Python bytecode at any given time.

    Solutions:
    - multiprocessing for CPU-bound tasks
    - asyncio for I/O-bound tasks
    - alternative interpreters (PyPy)
    """
    pass

In standard CPython, the GIL (Global Interpreter Lock) allows only one thread at a time to execute Python bytecode. Threads therefore will not speed up CPU-heavy computation. It is worth adding that since Python 3.13 there is a separate free-threaded build without the GIL (PEP 703), officially supported in 3.14 (PEP 779) but still optional. The second area is asynchronous programming:

# 2. Async Python
async def explain_async():
    """
    async/await - Python's concurrency model.
    - async def - defines a coroutine
    - await - waits for the result of an async operation
    - Ideal for I/O-bound operations
    """
    pass

The asyncio module provides support for async/await. The rule to remember: async/await for I/O-bound operations (network, database, files), multiprocessing for CPU-bound work. The third area is design patterns, which you know from the architecture lesson:

# 3. Design Patterns
def explain_patterns():
    """
    Most important patterns:
    - Repository Pattern - data access abstraction
    - Dependency Injection - loose coupling
    - Factory Pattern - object creation
    - Observer Pattern - reactivity
    """
    pass

In an interview, the name of a pattern is not enough, show an example from your own project, such as DocumentRepository. The fourth area is system design:

# 4. System Design
def design_rag_system():
    """
    Components:
    1. API Gateway - routing, auth
    2. RAG Service - query processing
    3. Vector Database - embeddings storage
    4. LLM Service - text generation
    5. Cache - Redis for frequent queries
    6. Monitoring - Prometheus + Grafana
    """
    pass

This is exactly the architecture of your capstone project. Explain why you chose each component, because that is what they will ask about.

There will also be questions about tools. You create a virtual environment with python -m venv .venv and activate it on Linux and macOS with source .venv/bin/activate. The requirements.txt file lists the dependencies with their versions. In FastAPI, Pydantic validates data and defines request and response models. By default, pytest discovers test_*.py and *_test.py files.

Where to Look for Jobs

The last step is knowing where to hunt for offers. Job sites change over time (GitHub Jobs and Stack Overflow Jobs no longer exist), so treat this list as a starting point:

## Junior/Mid Python Developer

1. **LinkedIn Jobs** - best source
2. **NoFluffJobs** - Polish IT market
3. **JustJoinIT** - startups and corporations
4. **Bulldogjob** - Polish IT job board
5. **Wellfound** (formerly AngelList Talent) - startups, international offers

## Freelance

1. **Upwork** - long-term projects
2. **Toptal** - premium, requires verification
3. **Fiverr** - smaller projects

## Open Source

1. Contribute to projects you use
2. Build your reputation
3. Network with developers

Open source is an often underrated path: a contribution to a library you use is public proof of your skills and a way to meet experienced developers.

Next Steps

The plan for the coming weeks is simple: complete the Capstone Project, publish it on GitHub, update your CV and LinkedIn, apply for positions and keep learning. My advice: do not wait until you feel "ready". Apply once you have one solid project, because interviews themselves are the best training.

Remember: this is not the end, it is the beginning of your Python adventure, and every future expedition starts with the map you drew in this module.

Code for this lesson: main.py
# ===========================================
# Safari Capstone: Core Service Layer
# ===========================================
# Implement the core business logic service that
# manages wildlife operations and analytics.

from dataclasses import dataclass, field
from datetime import datetime
from typing import Optional
import json

# --- Models ---
@dataclass
class Animal:
    animal_id: str
    species: str
    name: str
    weight_kg: float
    region: str

@dataclass
class Observation:
    obs_id: str
    animal_id: str
    latitude: float
    longitude: float
    observer: str
    timestamp: str = ""

# --- Repository ---
class AnimalRepository:
    def __init__(self):
        self._data = {}

    def save(self, animal): self._data[animal.animal_id] = animal
    def get(self, aid): return self._data.get(aid)
    def get_all(self): return list(self._data.values())
    def delete(self, aid): return self._data.pop(aid, None) is not None
    def find_by_species(self, sp):
        return [a for a in self._data.values() if a.species.lower() == sp.lower()]

# --- Core Service ---
class SafariService:
    """Core business logic for the safari management system."""

    def __init__(self, repo: AnimalRepository):
        self.repo = repo
        self.observations: list[Observation] = []
        self._next_obs_id = 1

    def register_animal(self, species, name, weight_kg, region) -> Animal:
        """Register a new animal in the system."""
        prefix = species[:2].upper()
        count = len(self.repo.find_by_species(species)) + 1
        animal_id = f"{prefix}-{count:03d}"
        animal = Animal(animal_id, species, name, weight_kg, region)
        self.repo.save(animal)
        return animal

    def record_observation(self, animal_id, lat, lon, observer) -> Optional[Observation]:
        """Record a new wildlife observation."""
        animal = self.repo.get(animal_id)
        if not animal:
            return None
        obs = Observation(
            obs_id=f"OBS-{self._next_obs_id:04d}",
            animal_id=animal_id,
            latitude=lat,
            longitude=lon,
            observer=observer,
            timestamp=datetime.now().isoformat()
        )
        self.observations.append(obs)
        self._next_obs_id += 1
        return obs

    def get_species_stats(self) -> dict:
        """Get population statistics grouped by species."""
        stats = {}
        for animal in self.repo.get_all():
            species = animal.species
            if species not in stats:
                stats[species] = {"count": 0, "total_weight": 0.0, "regions": set()}
            stats[species]["count"] += 1
            stats[species]["total_weight"] += animal.weight_kg
            stats[species]["regions"].add(animal.region)
        # Convert sets to lists for JSON compatibility
        for sp in stats:
            stats[sp]["avg_weight"] = round(stats[sp]["total_weight"] / stats[sp]["count"], 1)
            stats[sp]["regions"] = list(stats[sp]["regions"])
        return stats

    def get_observation_count(self, animal_id: str) -> int:
        """Count observations for a specific animal."""
        return sum(1 for o in self.observations if o.animal_id == animal_id)

    def generate_report(self) -> str:
        """Generate a summary report of all wildlife data."""
        stats = self.get_species_stats()
        total_animals = self.repo.get_all()
        lines = [
            "=== Safari Wildlife Report ===",
            f"Total animals tracked: {len(total_animals)}",
            f"Total observations: {len(self.observations)}",
            f"Species tracked: {len(stats)}",
            ""
        ]
        for species, data in stats.items():
            lines.append(f"{species}: {data['count']} animals, "
                        f"avg {data['avg_weight']} kg, "
                        f"regions: {', '.join(data['regions'])}")
        return "\n".join(lines)

# --- Demo ---
repo = AnimalRepository()
service = SafariService(repo)

# Register animals
service.register_animal("Lion", "Simba", 195.0, "Savanna")
service.register_animal("Lion", "Nala", 130.0, "Savanna")
service.register_animal("Elephant", "Tembo", 5200.0, "Forest")
service.register_animal("Cheetah", "Duma", 52.0, "Grassland")

# Record observations
service.record_observation("LI-001", -2.33, 34.83, "Dr. Darwin")
service.record_observation("LI-001", -2.34, 34.84, "Dr. Darwin")
service.record_observation("EL-001", -2.41, 34.92, "Ranger Kate")

# Generate report
print(service.generate_report())
print(f"\nSimba observations: {service.get_observation_count('LI-001')}")
print(f"\nSpecies stats:")
print(json.dumps(service.get_species_stats(), indent=2))

# TODO: Add a method to find the most observed animal
# def most_observed_animal(self) -> Optional[str]:
#     counts = {}
#     for obs in self.observations:
#         counts[obs.animal_id] = counts.get(obs.animal_id, 0) + 1
#     if not counts:
#         return None
#     return max(counts, key=counts.get)

# TODO: Add data export functionality
# def export_data(self, format="json") -> str:
#     data = {
#         "animals": [vars(a) for a in self.repo.get_all()],
#         "observations": [vars(o) for o in self.observations],
#         "stats": self.get_species_stats()
#     }
#     return json.dumps(data, indent=2, default=str)

Docs entries used in this lesson

Spotted a mistake in this lesson?

Check yourself

Answer the questions from this lesson. Pick an answer to see right away whether it is correct.

  1. 1. What is GIL in Python?

  2. 2. What does asyncio provide in Python?

These are 2 of 5 questions for this lesson. Solve the rest in the game.

Hands-on tasks in the game

  • Horizontal ordering

    Arrange the command to create a Python virtual environment:

  • Click in order

    Click the elements to build the venv activation command (Linux/Mac):

  • Code editor

    Write a GitHub Actions configuration for CI of a Python project

  • Code editor

    Create the initial structure of the Capstone Project with the main module and configuration

  • Code editor

    Implement the core AI service with a prediction method

  • Code editor

    Create a REST API layer using FastAPI for the capstone project

  • Code editor

    Write tests for the capstone project using pytest

  1. QuestionGIL in Python
  2. Put in orderPython venv
  3. Click in orderActivate venv
  4. Coding taskGitHub Actions CI
  5. QuestionAsync Python
  6. Coding taskCapstone: Project Setup
  7. Questionrequirements.txt
  8. Coding taskCapstone: Core Service
  9. QuestionPydantic model
  10. Coding taskCapstone: API Layer
  11. QuestionPytest discovery
  12. Coding taskCapstone: Tests
  13. VideoCapstone Project - Theory Summary
  14. Project to submitSubmit Capstone Project to Mentor
  15. VideoModule Summary

Useful articles