Python Developer Roadmap Checklist (Basic to Advanced)

Phase 1: Python Basics (Week 1–2)

• Syntax & Variables
• Data Types (int, float, string, boolean)
• Conditional Statements (if, elif, else)
• Loops (for, while)
• Functions & Parameters
• User Input & Print Formatting
• Project: Simple calculator or number guessing game

Phase 2: Core Concepts (Week 3–4)

• Lists, Tuples, Dictionaries, Sets
• File Handling (read/write)
• Functions (scope, return values)
• Exception Handling (try, except)
• Object-Oriented Programming (classes, inheritance)
• Project: Contact Book using OOP and File I/O

Phase 3: Intermediate Python (Week 5–6)

• List Comprehensions
• Lambda, map, filter, zip
• Modules, Packages, Virtual Environment
• Python Standard Library (os, datetime, random, json)
• Project: JSON data parser or mini file organizer

Phase 4: Web Development (Flask/Django) (Week 7–10)

• Flask or Django basics
• Routing & Templates
• Forms and CRUD Operations
• REST API creation
• User Authentication
• Project: Blog app or To-Do List Web App
Phase 5: Automation & Scripting (Week 11–12)
• requests, BeautifulSoup, selenium
• Automate browser actions
• Schedule tasks using schedule or cron
• Excel or CSV report automation (pandas)
• Project: Web scraper + auto-email sender

Phase 6: Databases (Week 13–14)

• SQL Basics (Create, Read, Update, Delete)
• SQLite or PostgreSQL
• Connect Python to DB
• Use ORM (SQLAlchemy or Django ORM)
• Project: Inventory Management System

Phase 7: Advanced Topics (Week 15–17)

• API consumption (requests, httpx)
• Async programming (asyncio, aiohttp)
• Unit Testing (unittest, pytest)
• Docker Basics
• Git & GitHub
• Project: Dockerized API + Frontend Integration

Phase 8: Specialization (Choose One) (Week 18+)

• Data Science: numpy, pandas, matplotlib, scikit-learn
• Machine Learning: TensorFlow, PyTorch
• Web Dev (Advanced): Django REST Framework, JWT Auth
• Automation/DevOps: Scripting servers, CI/CD pipelines
• Project: Based on chosen path (e.g., ML model, data dashboard)

Phase 9: Portfolio & Job Prep

• GitHub Portfolio
• Personal Portfolio Website
• Resume + LinkedIn
• Practice DSA on LeetCode/HackerRank
• Mock Interviews
Here's a breakdown of Python Basics (Week 1–2), covering the core foundational skills
every Python developer needs to start with:

Python Basics (Week 1–2)

1. Syntax & Variables

Python has simple and readable syntax.
• No semicolons needed.
• Indentation defines code blocks (use 4 spaces or a tab).
x = 10 # variable assignment
name = "Alice"
Variables are dynamically typed, meaning you don't need to declare a type.

2. Data Types
Common built-in types:
• int – Integer (5, -2)
• float – Decimal number (3.14, -0.5)
• str – String ("Hello", 'World')
• bool – Boolean (True, False)
age = 25 # int
pi = 3.14 # float
name = "Charlie" # str
is_active = True # bool

3. Conditional Statements
Use if, elif, and else for decision making.
age = 18
if age >= 18:
print("Adult")
elif age > 12:
print("Teen")
else:
 print("Child")

4. Loops
• for loop: iterate over sequences
• while loop: repeat while a condition is true
# for loop
for i in range(5):
print(i)

# while loop
count = 0
while count < 5:
print(count)
count += 1

5. Functions & Parameters

Functions help reuse code and make programs modular.
def greet(name):
print("Hello", name)

greet("Alice")
With return value:
def add(a, b):
return a + b

result = add(5, 3)

6. User Input & Print Formatting

Use input() to take input and print() to display output.
name = input("Enter your name: ")
print(f"Welcome, {name}!") # formatted string (f-string)
 7. Project Ideas

Simple Calculator
a = float(input("Enter first number: "))
op = input("Enter operation (+, -, *, /): ")
b = float(input("Enter second number: "))

if op == '+':
print("Result:", a + b)
elif op == '-':
print("Result:", a - b)
elif op == '*':
print("Result:", a * b)
elif op == '/':
print("Result:", a / b)
else:
print("Invalid operator")

Number Guessing Game

import random

number = random.randint(1, 10)

guess = int(input("Guess a number between 1 and 10: "))

if guess == number:

print("Correct! ")
else:
print(f"Wrong! The number was {number}")
Here's a clear explanation of the Core Concepts (Week 3–4) in Python, building on the
basics and introducing intermediate-level tools and techniques:

Core Concepts (Week 3–4)

1. Lists, Tuples, Dictionaries, Sets

List – Ordered, mutable (can change), allows duplicates

fruits = ["apple", "banana", "cherry"]
fruits.append("orange")
print(fruits[1]) # Output: banana

Tuple – Ordered, immutable (cannot change), allows duplicates

coordinates = (10, 20)
print(coordinates[0])
Dictionary – Key-value pairs, unordered (as of older Python versions)
person = {"name": "Alice", "age": 25}
print(person["name"])
person["age"] = 26 # update value

Set – Unordered, unique values only

unique_numbers = {1, 2, 3, 3}
print(unique_numbers) # Output: {1, 2, 3}

2. File Handling (Read/Write)

Write to a file:
with open("data.txt", "w") as file:
file.write("Hello, world!")
Read from a file:
with open("data.txt", "r") as file:
content = file.read()
print(content)

3. Functions (Scope, Return Values)

 • Scope: Variables declared inside a function are local.
• Return: Functions can return data.
def multiply(a, b):
result = a * b
return result

print(multiply(2, 3)) # Output: 6

4. Exception Handling (try, except)

Handle runtime errors gracefully:
try:
result = 10 / 0
except ZeroDivisionError:
print("You can't divide by zero!")
You can also use finally and else blocks.

5. Object-Oriented Programming (OOP)

Classes & Objects
class Person:
def __init__(self, name):
self.name = name

def greet(self):
print(f"Hello, I'm {self.name}")

p1 = Person("Alice")
p1.greet()
Inheritance
class Student(Person):
def study(self):
print(f"{self.name} is studying.")
s1 = Student("Bob")
s1.greet()
s1.study()

6. Project: Contact Book (OOP + File Handling)

Description: Store, retrieve, and delete contact information using a text file.
Example:
class Contact:
def __init__(self, name, phone):
self.name = name
self.phone = phone

def __str__(self):
return f"{self.name}: {self.phone}"

def save_contact(contact):
with open("contacts.txt", "a") as file:
file.write(f"{contact.name},{contact.phone}\n")

def load_contacts():
contacts = []
try:
with open("contacts.txt", "r") as file:
for line in file:
name, phone = line.strip().split(",")
contacts.append(Contact(name, phone))
except FileNotFoundError:
pass
return contacts
# Example usage
c1 = Contact("Alice", "12345")
save_contact(c1)

for c in load_contacts():
print(c)

This stage helps solidify your understanding of data structures, OOP, and file interaction,
which are essential for any real-world application.

Here’s a breakdown of the Intermediate Python (Week 5–6) topics — essential for
writing more concise, modular, and powerful Python code.

Intermediate Python (Week 5–6)

1. List Comprehensions
A concise way to create lists.
# Traditional way
squares = []
for i in range(5):
squares.append(i * i)

# List comprehension
squares = [i * i for i in range(5)]
Supports conditions:
evens = [x for x in range(10) if x % 2 == 0]

2. Lambda, map, filter, zip

lambda: Anonymous functions

add = lambda a, b: a + b
print(add(2, 3)) # Output: 5

map(): Apply function to all items in a list

nums = [1, 2, 3]
squared = list(map(lambda x: x ** 2, nums))

filter(): Filter items by condition

even = list(filter(lambda x: x % 2 == 0, nums))

zip(): Combine iterables

names = ["Alice", "Bob"]
ages = [25, 30]
combined = list(zip(names, ages)) # [('Alice', 25), ('Bob', 30)]

3. Modules, Packages, and Virtual Environments

Modules
Any .py file you can import.
# math_utils.py
def add(a, b):
return a + b
# main.py
import math_utils
print(math_utils.add(2, 3))

Packages
Folders with __init__.py, can contain multiple modules.

Virtual Environment
Keeps dependencies isolated per project.
python -m venv venv
source venv/bin/activate # Linux/macOS
venv\Scripts\activate # Windows

4. Python Standard Library

os – Interact with the operating system

import os
print(os.getcwd()) # current directory
os.mkdir("new_folder") # create folder

datetime – Work with dates and times

from datetime import datetime
now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M"))

random – Generate random numbers

import random
print(random.randint(1, 10))

json – Encode/decode JSON

import json
data = {"name": "Alice", "age": 25}
json_str = json.dumps(data)
parsed = json.loads(json_str)

5. Project: JSON Data Parser or Mini File Organizer

JSON Data Parser Example

import json

with open("users.json", "r") as file:

users = json.load(file)

for user in users:

print(f"Name: {user['name']}, Email: {user['email']}")

Mini File Organizer

Organizes files in a folder based on file type.
import os
import shutil
def organize(directory):
for file in os.listdir(directory):
if file.endswith(".txt"):
shutil.move(file, "Text_Files/")
elif file.endswith(".jpg"):
shutil.move(file, "Images/")

organize(".") # Current folder

Web Development (Flask/Django) — Week 7–10

1. Flask or Django Basics

Flask
• Lightweight and flexible
• Good for small-to-medium apps
from flask import Flask
app = Flask(__name__)

@app.route("/")
def home():
return "Hello, Flask!"

if __name__ == "__main__":
app.run(debug=True)
Django
• Full-stack framework (ORM, admin panel, auth, etc.)
• Better for large, structured applications
django-admin startproject mysite
cd mysite
python manage.py runserver
 2. Routing & Templates
Flask Routing
@app.route("/about")
def about():
return render_template("about.html")
Django Routing (URLconf)
# urls.py
urlpatterns = [
path("about/", views.about),
]
Templates (Flask & Django use Jinja-like syntax)
<!-- HTML template -->
<h1>Hello, {{ name }}</h1>

3. Forms and CRUD Operations

Create, Read, Update, Delete (CRUD)
Flask Example (Simplified):
@app.route("/add", methods=["POST"])
def add():
name = request.form["name"]
db.session.add(User(name=name))
db.session.commit()
return redirect("/")
Django Example:
# models.py
class Task(models.Model):
title = models.CharField(max_length=100)

# views.py
def create_task(request):
if request.method == "POST":
 Task.objects.create(title=request.POST['title'])

4. REST API Creation

Flask + Flask-RESTful Example:
from flask_restful import Resource, Api

class Hello(Resource):
def get(self):
return {"message": "Hello World"}

api.add_resource(Hello, "/api")
Django REST Framework:
# views.py
from rest_framework.views import APIView
class HelloView(APIView):
def get(self, request):
return Response({"message": "Hello World"})

5. User Authentication
Django
Comes with built-in user model and auth views:
python manage.py createsuperuser
from django.contrib.auth import authenticate, login
Flask
Requires setup using Flask-Login:
from flask_login import LoginManager
You implement login routes, session handling, and password checks manually or with
extensions.

6. Project Ideas

Blog App (Django)

 • Models: Post, Comment
• Features: Login, Create Post, Edit/Delete, View Posts
• Admin panel via django.contrib.admin

To-Do List (Flask)

• User can create tasks
• Store tasks in SQLite
• Edit/delete tasks with buttons
• Use Bootstrap for UI

Example Flask To-Do Route

@app.route("/add", methods=["POST"])
def add_task():
task = request.form["task"]
new_task = Task(name=task)
db.session.add(new_task)
db.session.commit()
return redirect("/")

Tips:
• Start with Flask if you're new.
• Choose Django for production-scale apps with built-in tools.
• Use tools like Postman to test APIs.
• Style using Bootstrap or Tailwind CSS.

Flask Project Starter – To-Do List App

Project Structure:
todo-flask/
├── app.py
├── templates/
│ ├── index.html
└── static/
 └── style.css
app.py
from flask import Flask, render_template, request, redirect

app = Flask(__name__)
tasks = []

@app.route("/", methods=["GET", "POST"])

def index():
if request.method == "POST":
task = request.form["task"]
tasks.append(task)
return redirect("/")
return render_template("index.html", tasks=tasks)

if __name__ == "__main__":
app.run(debug=True)
templates/index.html
<!DOCTYPE html>
<html>
<head>
<title>To-Do List</title>
</head>
<body>
<h1>My To-Do List</h1>
<form method="post">
<input name="task" required>
<button type="submit">Add</button>
</form>
<ul>
{% for task in tasks %}
 <li>{{ task }}</li>
{% endfor %}
</ul>
</body>
</html>

Django Project Starter – Blog App

Commands:
django-admin startproject blog_project
cd blog_project
python manage.py startapp blog
blog/models.py
from django.db import models

class Post(models.Model):
title = models.CharField(max_length=100)
content = models.TextField()
created = models.DateTimeField(auto_now_add=True)
blog/views.py
from django.shortcuts import render
from .models import Post

def home(request):
posts = Post.objects.all()
return render(request, 'blog/home.html', {'posts': posts})
blog/templates/blog/home.html
<h1>My Blog</h1>
{% for post in posts %}
<h2>{{ post.title }}</h2>
<p>{{ post.content }}</p>
<hr>
{% endfor %}
Add to urls.py
from django.urls import path
from blog import views

urlpatterns = [
path('', views.home),
]

Automation & Scripting (Week 11–12)

1. requests, BeautifulSoup, selenium

requests: Makes HTTP requests

import requests

response = requests.get("https://example.com")
print(response.text)

BeautifulSoup: Parses HTML

from bs4 import BeautifulSoup

soup = BeautifulSoup(response.text, "html.parser")

title = soup.title.text
print(title)

selenium: Automates browsers (for dynamic websites)

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://example.com")
print(driver.title)
driver.quit()
Use Selenium when JavaScript is required to load content.
 2. Automate Browser Actions
With selenium, you can fill forms, click buttons, and extract content:
from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()
driver.get("https://google.com")

search = driver.find_element(By.NAME, "q")

search.send_keys("Python automation")
search.submit()

3. Schedule Tasks (Using schedule or cron)

Python schedule library:

import schedule
import time

def job():
print("Running scheduled task...")

schedule.every(5).seconds.do(job)

while True:
schedule.run_pending()
time.sleep(1)
cron (Linux/macOS) or Task Scheduler (Windows):
• Run scripts at specific times.
• Example cron job:
0 8 * * * /usr/bin/python3 /path/to/script.py
 4. Excel or CSV Report Automation (Using pandas)

Reading & Writing CSV:

import pandas as pd

df = pd.read_csv("data.csv")
df["Total"] = df["Price"] * df["Quantity"]
df.to_csv("report.csv", index=False)

Excel Support:
df.to_excel("report.xlsx", index=False)

5. Project: Web Scraper + Auto Email Sender

Step 1: Scrape Website (e.g., latest articles)

import requests
from bs4 import BeautifulSoup

url = "https://news.ycombinator.com/"
html = requests.get(url).text
soup = BeautifulSoup(html, "html.parser")

titles = [tag.text for tag in soup.select(".storylink")]

Step 2: Format Report

report = "\n".join(titles[:5])

Step 3: Send Email (with smtplib)

import smtplib
from email.mime.text import MIMEText

msg = MIMEText(report)
msg["Subject"] = "Daily Hacker News Digest"
msg["From"] = "[email protected]"
msg["To"] = "[email protected]"
with smtplib.SMTP("smtp.gmail.com", 587) as server:
server.starttls()
server.login("[email protected]", "your_password")
server.send_message(msg)

Bonus Tools:
• pyautogui: Automate mouse/keyboard (GUI automation)
• openpyxl: Advanced Excel editing
• tabulate: Pretty-print tables in console
• apscheduler: More powerful task scheduler

Databases (Week 13–14)

1. SQL Basics (CRUD)

SQL (Structured Query Language) is used to interact with relational databases.

Basic Commands:
CREATE TABLE products (
id INTEGER PRIMARY KEY,
name TEXT,
price REAL
);

INSERT INTO products (name, price) VALUES ('Pen', 1.5);

SELECT * FROM products;

UPDATE products SET price = 2.0 WHERE name = 'Pen';

DELETE FROM products WHERE name = 'Pen';

 2. SQLite or PostgreSQL

SQLite
• Lightweight, built-in
• Great for small/local apps

PostgreSQL
• Powerful open-source RDBMS
• Great for production environments
We’ll use SQLite for quick examples.

3. Connect Python to DB (Using sqlite3)

import sqlite3

conn = sqlite3.connect("inventory.db")
cursor = conn.cursor()

cursor.execute("CREATE TABLE IF NOT EXISTS items (id INTEGER PRIMARY KEY, name
TEXT, qty INTEGER)")
cursor.execute("INSERT INTO items (name, qty) VALUES (?, ?)", ("Pen", 100))

conn.commit()
conn.close()

Fetch Data:
cursor.execute("SELECT * FROM items")
rows = cursor.fetchall()
for row in rows:
print(row)

4. Use ORM (Object-Relational Mapper)

SQLAlchemy (for Flask or standalone)

from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.orm import declarative_base, sessionmaker
Base = declarative_base()

class Item(Base):
__tablename__ = 'items'
id = Column(Integer, primary_key=True)
name = Column(String)
qty = Column(Integer)

engine = create_engine("sqlite:///inventory.db")
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

item = Item(name="Book", qty=10)

session.add(item)
session.commit()

Django ORM
In models.py:
from django.db import models

class Product(models.Model):
name = models.CharField(max_length=100)
qty = models.IntegerField()
Use:
python manage.py makemigrations
python manage.py migrate
Then query:
Product.objects.create(name="Chair", qty=20)

5. Project: Inventory Management System

 Features:
• Add/edit/delete items
• View all items with quantity
• Store data persistently in a DB

Flask + SQLite Example (Very Basic):

from flask import Flask, request, render_template
import sqlite3

app = Flask(__name__)

@app.route("/", methods=["GET", "POST"])

def inventory():
conn = sqlite3.connect("inventory.db")
c = conn.cursor()
if request.method == "POST":
name = request.form["name"]
qty = int(request.form["qty"])
c.execute("INSERT INTO items (name, qty) VALUES (?, ?)", (name, qty))
conn.commit()
c.execute("SELECT * FROM items")
rows = c.fetchall()
conn.close()
return render_template("index.html", items=rows)

Summary

Topic Tool/Concept

SQL SELECT, INSERT, UPDATE, DELETE

Database SQLite (light), PostgreSQL (production)

Connector sqlite3, psycopg2, SQLAlchemy

ORM SQLAlchemy (Flask), Django ORM (Django)

Topic Tool/Concept

Project Inventory App: Add/view/update items

Advanced Topics (Week 15–17)

1. API Consumption (requests, httpx)

APIs allow your Python apps to interact with external services (e.g., weather, currency,
chatbots).

Using requests:
import requests

res = requests.get("https://api.github.com/users/octocat")
data = res.json()
print(data["name"], data["public_repos"])

Using httpx (supports async):

import httpx

response = httpx.get("https://api.github.com/users/octocat")
print(response.json())

2. Async Programming (asyncio, aiohttp)

Use async when handling many I/O-bound tasks (like web scraping, API calls).

asyncio Example:
import asyncio

async def say_hello():

await asyncio.sleep(1)
print("Hello async!")

asyncio.run(say_hello())
 aiohttp for async HTTP calls:
import aiohttp
import asyncio

async def fetch_data():

async with aiohttp.ClientSession() as session:
async with session.get("https://api.github.com") as resp:
print(await resp.json())

asyncio.run(fetch_data())

3. Unit Testing (unittest, pytest)

unittest Example:
import unittest

def add(a, b):

return a + b

class TestMath(unittest.TestCase):
def test_add(self):
self.assertEqual(add(2, 3), 5)

unittest.main()

pytest Example:
def test_add():
assert add(2, 3) == 5
Run tests with: pytest test_file.py

4. Docker Basics
Docker helps you package your app + environment into containers — great for consistent
deployment.
 Sample Dockerfile:
FROM python:3.11
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]

Build & Run:

docker build -t myapp .
docker run -p 5000:5000 myapp

5. Git & GitHub

Version control your code with Git and share/collaborate on GitHub.
Commands:
git init
git add .
git commit -m "Initial commit"
git remote add origin <repo-url>
git push -u origin main
Use .gitignore to exclude unnecessary files like __pycache__, .env, etc.

6. Project: Dockerized API + Frontend Integration

Project Idea:
• Flask API for products (GET, POST)
• React or simple HTML frontend to interact
• Dockerize both backend & frontend

Structure:
project/
├── backend/ (Flask)
│ ├── app.py
│ └── Dockerfile
├── frontend/ (HTML or React)
│ └── index.html
│ └── Dockerfile
├── docker-compose.yml

Sample Flask API (app.py)

from flask import Flask, jsonify, request
app = Flask(__name__)

data = [{"id": 1, "name": "Laptop"}]

@app.route("/items", methods=["GET"])
def get_items():
return jsonify(data)

@app.route("/items", methods=["POST"])
def add_item():
item = request.json
data.append(item)
return jsonify(item), 201

if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000)
docker-compose.yml
version: "3"
services:
backend:
build: ./backend
ports:
- "5000:5000"
frontend:
 build: ./frontend
ports:
- "3000:3000"

Summary

Topic Tool/Concept

API Usage requests, httpx

Async I/O asyncio, aiohttp

Testing unittest, pytest

Deployment Docker, Dockerfile

Collaboration Git, GitHub

Project Output Containerized API + UI

Here's a brief overview of Week 18+ Specialization paths — choose based on your
interests or career goals:

Week 18+: Specialization Tracks (Choose One)

1. Data Science
• Tools: numpy, pandas, matplotlib, seaborn, scikit-learn
• Skills: Data wrangling, visualization, and basic ML models
• Example Project: Sales dashboard, COVID trend analysis, or customer
segmentation

2. Machine Learning
• Tools: TensorFlow, PyTorch, scikit-learn
• Skills: Neural networks, model training, evaluation, and deployment
• Example Project: Handwritten digit recognizer (MNIST), sentiment analysis, or
chatbot with NLP
 3. Web Development (Advanced)
• Tools: Django REST Framework, JWT Auth, Celery, Redis
• Skills: RESTful APIs, user authentication, background tasks, and secure endpoints
• Example Project: E-commerce API, blog CMS backend, or task manager with user
login

4. Automation / DevOps
• Tools: Shell scripting, fabric, paramiko, GitHub Actions, Docker, Jenkins
• Skills: Server automation, cron jobs, deployment scripts, CI/CD pipelines
• Example Project: Auto-backup tool, deployment bot, or full pipeline with GitHub +
Docker

Project Suggestion (Choose Based on Path)

Path Project Example

Data Science Interactive data dashboard (with charts)

Machine Learning Train + deploy ML model (API)

Web Dev Secure, full-featured API backend

Automation Automated deployment + notification bot

Here's a concise and practical guide to building your Portfolio & Preparing for Jobs as a
Python Developer:

Portfolio & Job Prep (Final Phase)

1. GitHub Portfolio
• Upload all your projects (e.g., scraper, Flask app, ML models).
• Use clear README files: include project overview, features, tech used, how to run.
• Organize into folders and pin top repositories on your GitHub profile.
Pro Tip: Show progression — beginner to advanced projects.

2. Personal Portfolio Website

• Use HTML/CSS, Flask/Django, or static site generators like Jekyll.
• Include:
o About Me
o Projects (link to GitHub)
o Resume PDF download
o Contact form or email link

Bonus: Host on GitHub Pages, Netlify, or Vercel for free.

3. Resume + LinkedIn
• Keep it 1 page, with:
o Skills (Python, Flask, SQL, etc.)
o Projects (with GitHub links)
o Education/Certifications
o Work/Internships (if any)
• LinkedIn:
o Add project posts, GitHub link, and a clean headline (e.g., "Python
Developer | ML Enthusiast").

Pro Tip: Use keywords from job descriptions for better searchability.

4. Practice DSA (Data Structures & Algorithms)

• Platforms: LeetCode, HackerRank, Codeforces, GeeksForGeeks
• Focus on:
o Arrays, Strings, HashMaps, Recursion
o Sorting, Searching, Linked Lists, Trees
o DP and Graph basics (for advanced roles)

Start slow and build consistency (30–60 mins/day).

5. Mock Interviews
 • Use platforms like Pramp, Interviewing.io, or peer practice.
• Prepare:
o Intro pitch ("Tell me about yourself")
o Explaining projects clearly
o Whiteboard or screen-share DSA problems

Bonus: Record yourself — review and refine.

Final Checklist Before Applying:

Task

GitHub with 4–6 quality projects

Clean resume with project links

Portfolio site published

50+ DSA problems solved

At least 2 mock interviews done

Absolutely! Here's a detailed suggestion for both a sample portfolio website structure
and a resume template tailored for:
1. Python Developer
2. Data Analyst

Sample Portfolio Website (For Both Roles)

Tools You Can Use:

• Static: HTML + CSS + Bootstrap
• Dynamic: Flask or Django
• Hosting: GitHub Pages, Netlify, or Vercel

Suggested Sections:
1. Home Page
 • Short intro (“Hi, I’m Alex, a Python Developer/Data Analyst…”)
• Highlight main skills and link to resume
2. About Me
• Brief bio
• Education
• Interests in tech or data
3. Projects
For each project:
• Title + Short description
• Tools used (e.g., Python, Pandas, SQL)
• GitHub link
• Screenshots or demo video
4. Resume
• Button to download PDF
• Optional embedded resume view
5. Contact
• Email
• LinkedIn
• (Optional) Contact form

Project Suggestions (Include in Portfolio)

Python Developer
• Web scraper (BeautifulSoup + requests)
• Flask/Django web app
• API project
• Automation script (e.g., email report sender)
• Inventory/CRUD app with DB

Data Analyst
• EDA notebook (CSV or Excel dataset)
• Data visualization dashboard (Plotly, Seaborn)
• SQL + Pandas project
 • Machine learning prediction (e.g., house price)
• Interactive dashboard (Streamlit or Tableau Public link)

Sample Resume (1 Page Template)

For Python Developer

Name
Email | LinkedIn | GitHub | Portfolio

Summary:
Python Developer with hands-on experience building web applications, APIs, and
automation tools. Proficient in Flask, SQL, and scripting.

Skills:
Python, Flask, SQL, HTML/CSS, Git, REST APIs, Selenium, Docker

Projects:

To-Do List Web App – Flask app with user auth, SQLite, and CRUD

Web Scraper – Automates data collection from job sites using BeautifulSoup

JSON Data Parser – Script that processes and structures raw JSON files

Experience:
Intern – Software Dev, XYZ Corp (3 months)
- Built internal tools for CSV-to-JSON conversion
- Automated reports via email using Python

Education:
B.Sc. in Computer Science – University Name

For Data Analyst

Name
Email | LinkedIn | GitHub | Portfolio
Summary:
Data Analyst with strong Python, Excel, and SQL skills. Experienced in data cleaning,
visualization, and deriving insights from real-world datasets.

Skills:
Python, Pandas, NumPy, Matplotlib, Seaborn, Excel, SQL, Power BI, Tableau

Projects:

Sales Data Dashboard – Visualized regional sales trends using pandas + matplotlib

HR Attrition Analysis – Performed EDA on employee dataset; shared insights in

dashboard
COVID Trends Tracker – Web-scraped data, plotted trends over time

Certifications:
Google Data Analytics | SQL for Data Science (Coursera)

Education:
B.A. in Statistics – University Name