Index Ai Academy
Phase 11 · Career

Roles, résumé and the search

What AI, ML and data engineering postings ask for, résumé bullets that carry a number, a 100-word project summary, a take-home as a portfolio piece and how to read an offer.

About 35 minutes · A free account opens the whole lesson.
Already have an account? Sign in to open this lesson

What it covers8

Why it matters

A job search is a small project with its own numbers: how many postings fit, how many replies, how many interviews. The people reading your résumé spend about as long on it as you spend on a search result, so it has to show the work in numbers and in things they can open. You already have the evidence: capstones, services, models you shipped. This lesson turns it into bullets, a summary and a repeatable process, and gives you a way to read an offer.

What you'll be able to do

  • Read a posting for the skills it names and sort them against the AI, ML and data engineering roles
  • Write résumé bullets that start with a verb and carry a number
  • Write a 100-word summary of a project that you can also say out loud
  • Treat a take-home as a portfolio piece, and read an offer as base, bonus and equity over time
Quick check
A guess before you start. A résumé bullet says "Responsible for the churn model". What is wrong with it?
  1. It is too short
  2. It is written in the present tense, not the past
  3. It names the model
  4. It says what you held, not what changed or by how much
Show the answer

It says what you held, not what changed or by how much

The reader wants to know what changed because of you. "Responsible for" says nothing about that, and has no number.

The practice: three roles and a résumé that shows its work

Job titles in this field overlap, and every company uses them a little differently, so read each posting for the skills it names, not its title. Three families cover most of what you will see.

  • An AI engineer builds products on top of models: prompts, retrieval, tool use, evals, cost and latency. This is the territory of the academy's courses on building with LLMs, modern LLM engineering, MCP and agent harnesses.
  • An ML engineer trains models and runs them: features, training, tracking, a registry, serving and drift. The academy's machine learning, deep learning and "ML in production" lessons cover it.
  • A data engineer moves and shapes data: pipelines, warehouses, quality checks, transformations. See the data engineering track of this course, including Transformations: staging, models and tests.

The picture sorts a typical set of skills across the three.

Try it now

Postings vary by company. Read each one for the skills it names, and sort them like this.

Quick check
From Writing for engineers: which of these is the clearest first line of a README?
  1. A list of every dependency
  2. The license text
  3. A joke about the project name and its logo, written in the first line
  4. A sentence saying what the project does and who it is for
Show the answer

A sentence saying what the project does and who it is for

A reader decides in seconds whether to go on. What it does and for whom answers that.

One strong résumé bullet and one weak one

blankWeakStrong
Starts with"Responsible for the model""Cut p95 latency from 240 ms to 90 ms"
NumberNoneBefore and after, with units
What you did"Worked on"A verb that says what: built, cut, found
EvidenceNothing to open"On GitHub: a churn model with a registry and a monitor"
LengthThree lines of dutiesOne or two lines

A strong bullet answers one question for the reader: what changed because of you, and by how much?

Quick check
Which bullet is strongest?
  1. Helped the team with ML projects
  2. Responsible for model performance in the team
  3. Worked on the serving layer
  4. Cut p95 latency from 240 ms to 90 ms by batching requests
Show the answer

Cut p95 latency from 240 ms to 90 ms by batching requests

It starts with a verb, says what changed and gives a before and after with units, and names how.

The search is a funnel

Applications turn into replies, replies into screens, screens into interviews and interviews into offers, and each step keeps only a share. The shares vary a great deal, so use your own numbers rather than anyone's average. What the funnel tells you is where to put your time. If few applications turn into replies, the résumé or the targeting is the problem. If replies do not become offers, practice interviews. Each fix is different, and you only know which you need if you count.

Quick check
What does this print: the share of an 8-skill posting that you cover with 5 of its skills, to three places?
print(round(5 / 8, 3))
  1. 5.0
  2. 0.625
  3. 0.375
  4. 1.6
Show the answer

0.625

5 / 8 is 0.625.

Quick check
Where do you put your next hour if applications keep getting no replies?
  1. On the résumé and which postings you target
  2. On practicing interview questions
  3. On sending the same résumé to more postings
  4. On waiting a week longer
Show the answer

On the résumé and which postings you target

No replies at the first step of the funnel points to the résumé or the targeting. Interview practice helps after replies come.

In your own words
In your own words: what does a strong résumé bullet contain, and why does "responsible for" fail?

Write a sentence or two, then compare it with a good answer in the lesson.

Your turn: six bullets and a summary

A posting is a list of skills, and your résumé is a list of evidence. Matching the two is set arithmetic, which is how a tool that filters résumés sees them and how you can check your own.

Setup (runs before every cell) · 5 lines

The lesson runs this once, before its first cell, and every cell, drill and example starts with what it defines. A cell that changes a setup object changes it for the cells after it, until the page reloads.

POSTING = ["python", "sql", "docker", "airflow", "pytorch", "evals", "git", "aws"]
YOU = ["python", "sql", "git", "pytorch", "evals"]

VERBS = {"built", "cut", "reduced", "raised", "shipped", "wrote", "designed", "added",
         "found", "fixed", "moved", "measured", "trained", "deployed", "automated"}
have = [skill for skill in POSTING if skill in YOU]
missing = [skill for skill in POSTING if skill not in YOU]
print("covered", len(have), "of", len(POSTING), "=", len(have) / len(POSTING))
print("missing:", missing)

You cover 5 of 8 skills, 0.625 of the posting. The three you lack are docker, airflow and aws. That is a to-do list and not a verdict: some you can learn in a weekend and put in a project, and a posting is rarely a strict list. What you should not do is claim a skill you cannot show.

Quick check
What does this print: the number of posted skills you have, out of how many?
posting = ['python', 'sql', 'docker', 'airflow']
you = ['python', 'sql', 'git']
have = [s for s in posting if s in you]
print(len(have), len(posting))
  1. 2 4
  2. 2 3
  3. 3 4
  4. 4 2
Show the answer

2 4

python and sql are in both lists; docker and airflow are not in yours. That is 2 of the 4 posted.

A bullet can be checked too. A simple automatic check looks for four things: it starts with an action verb, it contains a number, it is not too long and it does not say "responsible for". The check cannot tell you whether the bullet is true or well chosen, but it catches the commonest weak ones before a person has to.

Worked example

Worked example: a week of the search, as numbers

Put the week into a small table and let the code tell you where the funnel is leaking.

Uses the setup above, 5 lines.

week = {"applied": 11, "replies": 0, "screens": 0}
postings = [("ML engineer", 8, 5), ("AI engineer", 8, 4), ("Data engineer", 8, 3)]
print("replies:", week["replies"], "of", week["applied"])
for title, named, have in postings:
    share = round(have / named, 2)
    note = "apply" if share >= 0.6 else "build one project first"
    print(title.ljust(14), "coverage", share, "->", note)
It runs right here in your browser, with nothing to install.

Eleven applications and no replies points at the first step of the funnel. The postings show why: coverage is 0.62 for the ML role, 0.5 for the AI role and 0.38 for the data role, and a rule of applying at 0.6 or more leaves only one of the three. Add one project that shows a missing skill, and the data engineer posting moves into range.

Drill

The skills you still need

Write skill_gap(posting, you). Return a tuple (share, missing): share is the fraction of the posted skills that are in you (0.0 for an empty posting), rounded to 3 places, and missing is the list of posted skills not in you, in the posting's order. Compare in lower case.

Uses the setup above, 5 lines.

def skill_gap(posting, you):
    return 0.0, []


print(skill_gap(["Python", "SQL", "Docker"], ["python", "git"]))
In the lesson, your code is checked as you write it.
Drill

Check a bullet

Write bullet_problems(bullet). Return a list of problems, in this order, or an empty list: "start with a verb" unless the first word, lower-cased, is in VERBS (defined in the setup); "add a number" if the bullet has no digit; "too long" if it has more than 25 words; "say what changed, not what you were responsible for" if it contains responsible for in any case.

Uses the setup above, 5 lines.

def bullet_problems(bullet):
    return []


print(bullet_problems("Responsible for the churn model"))
In the lesson, your code is checked as you write it.
Written brief · Resume bullets

Six résumé bullets from your own projects

Pick the projects you built in this academy (a capstone, a service, a model). Write six bullets for a résumé, for an AI or ML engineer role. Use real numbers from your own work: a latency, a score, a cost, a row count.

It must

  • Every bullet starts with a verb that says what you did
  • Every bullet has a number with its unit
  • Each bullet fits on two lines at most

Go further

  • Names the tool or method in each bullet

The template

## Project 1
Two bullets.

## Project 2
Two bullets.

## Project 3
Two bullets.
In the lesson, you write over it, 90 to 220 words, and the tutor can mark it.
Written brief · Project summary

A 100-word project summary

Write the short summary that goes at the top of the README of your best project, and that you would say out loud in an interview: the problem, what you built, one result with a number, and one thing you would do next.

It must

  • States the problem for a person, not a technology
  • Gives one result with a number and what it was measured on
  • Says what you would do next

Go further

  • Links the repository

The template

## The problem
Who needs this, in one sentence.

## What I built
In two sentences.

## A result
One number, and what it was measured on.

## Next
One thing I would do with more time.
In the lesson, you write over it, 70 to 130 words, and the tutor can mark it.

Evidence you can open

A claim on a résumé is a claim. A link to a repository with a README, a passing CI run and a model card is evidence. Where you can, make each bullet point at something a reader can open in a minute: a repository, a dashboard screenshot, a short write-up. Keep two or three projects at the top, with a number each, and let the rest follow. A reader who opens one project and finds it tidy will trust the others.

In your own words
A posting names a tool you have never used. What do you do before applying?

Write a sentence or two, then compare it with a good answer in the lesson.

On the job: the take-home and the offer

Many hiring processes include a take-home: a small project you do on your own time. Treat it as a portfolio piece. Keep it within the time asked, put it in a repository with a README that has the problem, your approach, a result with a number and what you would do next, and say how long it took. A clean small project beats an enormous one the reviewer cannot finish reading.

An offer is several numbers over time. The base is the yearly salary. A bonus is often a percent of base. Equity vests over years, often four, with a first-year "cliff" before any of it is yours. Compare offers by the first year's total and by what you would hold after four. Ask questions: how is the bonus decided, what happens to equity if you leave, how is the role evaluated. The numbers in the lesson are invented to show the arithmetic, not what any role pays.

Where it comes up in a week

You keep a short spreadsheet: one row per posting, with the date, the skills it names, your coverage, the reply and the stage. On Sunday you count. Eleven applications and no replies, and your coverage on those postings is under 0.5: the targeting is off, so you pick postings you cover at 0.6 or more and add one project that shows the missing skill. Next week the numbers are different, and you know why.

Goes deeper in

In your own words
What does a take-home need to show besides working code?

Write a sentence or two, then compare it with a good answer in the lesson.

Practice what you just read

  • 2 code examples you can edit and run
  • a practice exercise that checks your code
  • a 5-question quiz
  • 8 review cards for spaced repetition

Try a quiz question

How should you read a job posting?

  1. For the skills it names, whatever the title says
  2. For its title only
  3. For the company's name and how well known it is
  4. Only for the salary

Answer it at the end of the lesson to see if you're right, and why.

Before this lesson

Keep learning

Where this lesson leads.

575 lessons in thirteen phases. 176 are free without an account, and a free account opens the rest. See every lesson.

Phase 11 · about 34 hours of study

Professional practice

Design, ship and run real systems, work well in a team, and get hired 43 lessons 1 free
  1. System design fundamentals FreeRequirements, rough numbers, the standard parts and where systems break.40 min
  2. Caches, queues and background jobsSpeed reads with caches, and move slow work to queues that retry safely.40 min
  3. Designing AI systemsLatency, cost, routing, fallbacks and guardrails for features built on models.40 min
  4. Containers and deploymentPackage an app as an image, configure it with the environment, and roll out safely.45 min
  5. CI/CD pipelinesTest every change automatically, and ship with gates, flags and rollbacks.40 min
  6. Docker ComposeSeveral containers together: service names, volumes, secrets and start order.40 min
  7. Kubernetes basicsDesired state, Deployments and Services, labels, probes and rolling updates.40 min
  8. Cloud for AI engineersAccess policies and least privilege, storage, compute choices, managed model endpoints, secrets and budgets.30 min
  9. Metrics, dashboards and alert rulesCounters, gauges and histograms, a rate from a counter, a percentile from buckets, a dashboard panel and an alert rule that fires on a sustained condition.40 min
  10. Reliability and incidentsSLOs, error budgets, alerts, on-call and blameless postmortems.40 min
  11. Incident lab: from the page to the postmortemOne incident run from the page to the all-clear: decide the mitigation, work out the impact in failed requests and error budget, and write a blameless postmortem, a status update and a runbook entry.40 min
  12. Measuring an AI feature from its logsTyped views over event logs, metric specs, cost from a price table, and rollups you can rerun.40 min
  13. A/B testing a model changeHash assignment, per-user results from raw logs, sample ratio checks, guardrails and a decision rule.40 min
  14. Columnar files and a local warehouseRows against columns, the encodings that shrink a column, Parquet's row groups and the ranges that let a query skip them, and SQL over files with DuckDB.40 min
  15. Data quality checks and contractsSix properties of a delivery you can test, each as a count of rows that break it, a contract with the producer, and when to block, quarantine or warn.40 min
  16. Transformations: staging, models and testsRaw, staging, facts and marts as SQL models run in dependency order in DuckDB, tests as queries that count the rows that break a rule, an incremental load that is safe to rerun, and the same models as dbt files.45 min
  17. Streams and windowsEvents that never stop arriving: event time against arrival time, tumbling, sliding and session windows, a watermark for late events, and counting each event once.40 min
  18. Labels and annotator agreementLabels as measurements: agreement and Cohen's kappa, the pair of classes annotators confuse, votes and gold questions, and what wrong labels do to a model and a test score.45 min
  19. Experiment tracking and reproducible runsA run record of settings, seed, data and code behind every score, a run log in a dozen lines, and comparing settings across seeds.40 min
  20. Hyperparameter searchWhat a grid costs, random search on a log scale, stopping weak settings early, and why the winner's validation score flatters it.40 min
  21. Versioning data and modelsFiles stored under the hash of their contents, a manifest that names a whole dataset, and lineage from data and code to each model.35 min
  22. A model registry and promotionVersions under one name, an alias for the live one, gates a candidate must pass, group by group, and a rollback that moves a pointer.40 min
  23. Feature pipelines and training-serving skewWhy a model that passes offline fails live: statistics refit at serving, two code paths, and features from the future, with the fix for each.40 min
  24. Batch and online inferencePredict ahead of time or on request: when the inputs exist, latency near a server's limit, batching what waits, cost, and a hybrid with a freshness limit.40 min
  25. Monitoring a model: drift and decayWhy a model worsens with no code change: data drift and concept drift, a measure of how far inputs have moved, thresholds set from noise, and labels that arrive late.45 min
  26. Retraining and pipelinesWhen to retrain and on which weeks, training as steps in dependency order, a cache that reruns only what changed, and guards before and after.45 min
  27. Designing ML systemsOne method for an ML design, goal and metric to retraining, with the sums that size it: requests a second at peak, a year of feature storage, a label delay and a latency budget.45 min
  28. Datasheets: documenting a datasetThe document that travels with a dataset: a profile by column and by group, claims a program can check, splits that don't leak, a scan for personal data, and the license and limits only people can write.45 min
  29. Curation, active learning and synthetic dataThree levers on a training set: removing copies and broken rows, letting a model choose which rows to label, and manufacturing rows, which helps only when their source knows more than you do.45 min
  30. Measuring fairnessBreak a model's results down by group: selection rate, true and false positive rates and precision, why they can't all be equal, what each fix costs, and when a group is too small to judge.40 min
  31. Privacy engineeringWhy removing names isn't anonymity, how to hold less (minimization, retention, keyed pseudonyms), the idea behind differential privacy and its budget, what a model remembers, and a deletion that reaches every store.40 min
  32. A red-team labAttack a simulated assistant methodically: eight kinds of attack run as a suite, success rates beside ordinary requests blocked, fresh attacks to test the fixes, where a defense belongs, and findings kept as release tests.45 min
  33. What regulation asks of an engineerRisk tiers that follow a system's use, the requirements for high-risk systems as artifacts an engineer builds, evidence tied to a model version, a model card a program can check, and legal dates kept as data.35 min
  34. Git for teamsBranches, pull requests, rebasing and how a three-way merge finds conflicts.40 min
  35. Writing for engineersREADMEs, design docs, commit messages and bug reports people can act on.35 min
  36. Scoping and estimating workA vague request cut into tickets with acceptance criteria and a first shippable slice, estimates as ranges, an honest update for a slip, and a ticket linked to its pull request.30 min
  37. Roles, résumé and the searchWhat AI, ML and data engineering postings ask for, résumé bullets that carry a number, a 100-word project summary, a take-home as a portfolio piece and how to read an offer.35 min
  38. Interviews and your portfolioShow your work, and solve interview problems the way professionals do.40 min
  39. Code reviewWhat to look for, how to give and take feedback, and automating the routine checks.35 min
  40. Reading unfamiliar codeFind your way around a big codebase fast, with tools that map it for you.35 min
  41. Working with AI coding toolsGive agents good context, keep tasks small, and check every change they make.35 min
  42. Capstone: ship a production AI serviceAn AI-backed service with validation, caching, rate limits, fallbacks, logging and evals.45 min
  43. Capstone: take a model to productionA churn model through a data contract, a tracked run, a registry gate by slice, hybrid serving, a PSI monitor and one retrain, shipped with a datasheet, a model card, a fairness audit, a design doc and a runbook.45 min

Never trained an AI? Teach a small one to write, right in your browser. It takes about 20 seconds and needs no account. Teach it to write