Data engineering roadmap, portfolio, certifications and resume

Badges or evidence?

Roadmap, portfolio, certifications and resume

Words you’ll meet in this lesson

Your data engineering career plan at three levels

Certifications and other ways to prove skills

Exam fees are roughly US$150–200 each as of mid-2026 (DataCamp’s certification guide, July 2026). Names, fees and validity change; always check the provider’s certification page.

Four ways to prove your skills

From job posts to interviews

1. Study 20 job posts

   Collect 20 data engineer postings for roles you want (product companies, service companies, start-ups) and count the skills that repeat.

   In India, SQL, Python, Spark, a cloud, Airflow and data modelling appear in most posts. The posts tell you what to learn and which certification matters.

2. Make a time-boxed plan

   hours_needed, hours_per_week = 367, 12
   weeks = -(-hours_needed // hours_per_week)
   print(weeks, "weeks, about", round(weeks / 4.3, 1), "months")

   31 weeks, about 7.2 months
   Honest hours per week turn a vague goal into a date. Skip what you already know well; spend most time on gaps.

3. Build one end-to-end project

   Ingest real data (for example from data.gov.in or a public API), land it raw, clean it with Spark or dbt, run quality checks, orchestrate with Airflow, and serve a small dashboard.

   One complete, documented project beats five half-finished notebooks. Interviewers ask about decisions, so write them down in the README.

4. Write quantified resume bullets

   bullet = "Reduced a nightly PySpark job from 3 h to 25 min"
   print("has a number:", any(ch.isdigit() for ch in bullet))
   print("starts with action:", bullet.split()[0] in ("Built", "Reduced", "Designed"))

   has a number: True starts with action: True
   Use action + tool + scale + result. Keep the resume to one page as a fresher, with projects above a skills list.

5. Apply with referrals and polish your profiles

   Update LinkedIn and GitHub, ask former classmates and colleagues for referrals, apply on job portals and company career pages, and track every application in a sheet.

   Referrals and direct messages to hiring managers often get faster replies than portal applications alone.

6. Prepare for interviews

   Practise SQL and Python problems, Spark and data-modelling questions, a system design for a pipeline, and STAR stories about your projects. The next lesson has a full question bank.

   Most data engineering rounds are SQL, coding, a project deep-dive, design and a behavioural round.

A resume in 30 seconds: what the recruiter sees, and what she checks

Step through the six frames. Left: Kabir’s resume as the recruiter scans it. Right: the questions in her mind.

Real-time scenarios: roadmap, resume and portfolio

Three live scenarios: a personal roadmap (numbers from the program below), one resume bullet improving from 0/4 to 4/4, and an advanced look at a portfolio repository that reviewers trust.

An 8-month roadmap built from Kabir’s own skills

These figures come from the program in “Run it on your PC” below. It skips what Kabir already knows and spreads the rest across 12 hours a week.

One bullet, four versions

The scores come from the program below, which checks each bullet for an action verb, a named tool, a number and an impact. Watch a vague line become an interview magnet.

A portfolio repository a senior engineer would trust

Hiring managers often open a candidate’s main project for two minutes. Watch what turns a folder of notebooks into evidence of professional skill.

Portfolio project ideas with Indian data

A one-page fresher resume, top to bottom

Sources

• Certification names, fees and validity: DataCamp, “Best data engineer certifications”, July 2026; check each provider’s official certification page before booking.

Plan your roadmap from your own skills

Rate yourself from 0 to 3 in each skill. The program works out the hours you still need and the weeks it will take at your pace. Then try the challenges: job-post keyword counts, bullet checks, application tracking and certification choices.

skills = {            # skill: (hours from zero, your level 0-3)
    "SQL": (60, 2),
    "Python": (60, 2),
    "Spark": (70, 0),
    "Airflow": (30, 0),
    "Cloud": (50, 1),
    "Project": (60, 0),
}
hours_per_week = 10
total = 0
for skill, (hours, level) in skills.items():
    need = round(hours * (3 - level) / 3)
    total += need
    print(f"{skill:8}: {need:3} h")
print(f"total {total} h -> {total / hours_per_week:.0f} weeks at {hours_per_week} h/week")

• need = round(hours * (3 - level) / 3)Level 3 means nothing left to learn; level 0 means the full hours.
• hours_per_week = 10Be honest: a plan based on real hours gives a real date.

Run it on your PC: roadmap planner and resume-bullet scorer

This program plans a 10-skill data engineering roadmap from your self-ratings and weekly hours, then scores resume bullets for an action verb, a named tool, a number and an impact. Edit the levels, hours and bullets to your own and run it again. Save it as career_planner.py.

"""Plan a data engineering learning roadmap from your current skills,
then score resume bullets the way a busy reviewer would."""
import re

# 1) skills: (hours needed from zero, your level 0-3)
skills = {
    "SQL (joins, windows, CTEs)": (60, 2),
    "Python for data": (60, 2),
    "Linux, Git, shell": (25, 1),
    "Data modelling (star schema)": (30, 0),
    "Spark / PySpark": (70, 0),
    "Airflow orchestration": (30, 0),
    "Kafka basics": (30, 0),
    "One cloud (storage, Spark, warehouse)": (50, 0),
    "Lakehouse: Delta / Iceberg, dbt": (40, 0),
    "Portfolio project end to end": (60, 0),
}
HOURS_PER_WEEK = 12
week, plan = 1, []
for skill, (hours, level) in skills.items():
    need = round(hours * (3 - level) / 3)
    if need == 0:
        continue
    weeks = -(-need // HOURS_PER_WEEK)          # ceiling division
    plan.append((week, week + weeks - 1, skill, need))
    week += weeks
print(f"Roadmap at {HOURS_PER_WEEK} hours a week:")
for start, end, skill, need in plan:
    print(f"  weeks {start:2}-{end:2}: {skill:38} ({need} h)")
print(f"Total: {sum(p[3] for p in plan)} hours, about {week - 1} weeks ({(week - 1) / 4.3:.1f} months)")

# 2) resume bullets: action verb + tool + number + impact
VERBS = ("built", "designed", "reduced", "migrated", "automated", "optimised", "optimized", "created", "led", "improved")
TOOLS = ("spark", "pyspark", "airflow", "kafka", "sql", "python", "dbt", "delta", "parquet", "aws", "azure", "gcp", "bigquery", "s3")
def score(bullet):
    b = bullet.lower()
    checks = {
        "action verb": b.split()[0] in VERBS,
        "tool named": any(t in re.findall(r"[a-z0-9]+", b) for t in TOOLS),
        "number": bool(re.search(r"\d", b)),
        "impact": any(w in b for w in ("reduc", "faster", "saving", "cut", "improv", "%", "from")),
    }
    return sum(checks.values()), [k for k, ok in checks.items() if not ok]

bullets = [
    "Worked on data pipelines using various tools.",
    "Responsible for Spark jobs.",
    "Built an Airflow DAG that loads 2 lakh orders a day into Delta tables.",
    "Reduced a nightly PySpark job from 3 h to 25 min by fixing skewed joins and partitioning by date.",
]
print("\nResume bullet scores (out of 4):")
for b in bullets:
    s, missing = score(b)
    print(f"  {s}/4  {b}")
    if missing:
        print(f"        missing: {', '.join(missing)}")

# In a terminal:  python career_planner.py

Turning skills into weeks

Three skills with your current level are converted into hours still needed and a running week count.

Worked examples: real problems, solved and traced in memory

Four career-planning calculations. Each runs live and is traced.

367 hours, 12 h/week, start 2026-11-01

31 weeks -> finish on 2027-06-06

job skills set, resume skills set

match  : ['python', 'spark', 'sql']
missing: ['airflow', 'aws', 'data modelling']
coverage: 50%

3 bullets

3 Built Kafka consumer for 5k events/s
2 Automated SQL checks
0 Helped team with reports

12% → 45% → 30%, target 2 offers

portals only   : 1.62% per application -> 124 applications
with referrals : 3.24% per application -> 62 applications

Check yourself

Quick revision

Interview and viva questions

Practice problems

Small career-planning programs. The last two are business-style tasks.

120 h, 9 h/week

14

print(-(-120 // 9))

list

[('SQL', 3)]

from collections import Counter
print(Counter(["SQL", "Spark", "SQL", "Python", "SQL", "Spark"]).most_common(1))

bullet

True

print(any(c.isdigit() for c in "Built 3 Airflow DAGs"))

two sets

50%

job, me = {"sql", "python", "spark", "aws"}, {"sql", "python", "excel"}
print(f"{len(job & me) / len(job):.0%}")

6/40

15%

print(f"{6 / 40:.0%}")

as given

1.57

print(round(60 * 0.15 * 0.50 * 0.35, 2))

dict

C

s = {"A": 2, "B": 4, "C": 1}
print(min(s, key=s.get))

50 apps, 10% → 13%

1.5 extra interviews

print(round(50 * (0.13 - 0.10), 1), "extra interviews")

2×5 + 5×2

20 h/week, 19 weeks

h = 2 * 5 + 5 * 2
print(h, "h/week,", -(-367 // h), "weeks")

Real-world scenario questions (asked in company interviews)

Career questions students and early-career engineers ask. Decide your answer first, then open the model answer.