Performance Engineer Resume Examples & Free Template (PDF, Word)

Lukas Reinhart’s Nordstrom resume comes pre-filled in this free template for performance engineers. Scroll down and there are 3 performance testing resume samples, a junior at Zoom up to a lead at Disney Streaming, plus my 6-step guide to load test, profiling and p99 bullets.

4.9 5.0
The Performance Engineer resume template with Lukas Reinhart’s details: profile summary, technical skills, education and bullets on load testing, profiling, capacity and Core Web Vitals
Emmanuel Gendre Ex-Google recruiter / Tech resume writer Updated Free, ATS-friendly, no signup

Interactive resume template generator

Interactive Performance Engineer Resume Template

Fill in the side panel, then download your resume as a PDF or a Word file.

Edits update live as you type. Toggle Edit to rewrite paper text directly.

Edit mode is on. Click anywhere on the resume to rewrite text. Side-panel placeholders still update live.

Lukas Reinhart Senior Performance Engineer

Seattle, WA • lukas.reinhart@gmail.com • +1 206-555-0187

Profile Summary

  • Senior Performance Engineer with 8 years of experience testing and tuning high-traffic retail and e-commerce platforms across web, mobile app and API traffic, specializing in load testing, JVM profiling and capacity planning.
  • Hands-on with load testing (k6, JMeter), profiling (async-profiler, Java Flight Recorder), APM (Datadog, OpenTelemetry), data (PostgreSQL, Redis) and cloud (AWS, Kubernetes).
  • Deep expertise in workload models from production traffic, p99 latency budgets, GC and query tuning and performance gates in CI, using the USE and RED methods to find the real bottleneck before a peak event.
  • Works closely with service owners, SRE, DBAs and front-end teams in release readiness reviews, peak rehearsals and latency incidents.
  • Mentors engineers on reading flame graphs and writing k6 scenarios, runs a monthly performance review with engineering leads, and wrote the team’s peak readiness checklist.

Technical Skills

Languages & Scripting:
Java, Python, Go, JavaScript, SQL, Bash
Load Testing Tools:
k6, JMeter, Gatling, LoadRunner, Locust
Profilers & Runtime Tools:
async-profiler, Java Flight Recorder, pprof, py-spy, Linux perf, G1 and ZGC tuning
APM & Observability:
Datadog, OpenTelemetry, Dynatrace, Grafana, Prometheus
Databases & Caching:
PostgreSQL, Redis, MySQL, PgBouncer, pg_stat_statements, EXPLAIN ANALYZE
Cloud, Containers & CI/CD:
AWS, Kubernetes, Docker, GitHub Actions, Jenkins, Terraform
Front-End Performance Tools:
Lighthouse, WebPageTest, Chrome DevTools, Core Web Vitals, Datadog RUM

Education

University of Washington B.S. in Computer Engineering
Seattle, WA • Sep 2014 to Jun 2018

Work Experience

Nordstrom Senior Performance Engineer
Seattle, WA • Jun 2022 to Present
  • Built k6 load, soak and spike suites for the checkout, cart and inventory APIs from production traffic mixes, running the Anniversary Sale rehearsal at 3.5x normal peak and finding 4 breaking points before launch.
  • Profiled the order routing service with async-profiler and Java Flight Recorder, removed lock contention on a shared price cache and retuned G1 heap settings, cutting p99 latency from 640 ms to 170 ms.
  • Built the peak capacity model in Python from 2 years of traffic and sales forecasts, setting EKS node group sizes and HPA targets so the platform took 4.2x normal traffic on Black Friday without a scaling incident.
  • Rolled out OpenTelemetry tracing across 46 services in Datadog APM, with RED dashboards per team, cutting the time to find the slow service in a latency incident from 50 minutes to 9 minutes.
  • Tuned the product catalog’s top 25 PostgreSQL queries with EXPLAIN ANALYZE and pg_stat_statements, adding covering indexes, PgBouncer pooling and a Redis read cache, cutting p95 query time from 1.2 s to 140 ms.
  • Agreed p99 latency budgets and SLOs for 32 customer-facing endpoints with 14 product teams and SRE, with burn-rate alerts in Datadog, raising monthly SLO attainment from 91% to 99.2%.
  • Added k6 performance gates to the GitHub Actions pipelines of 22 services, failing any build whose p95 latency rose more than 10% over baseline, and caught 31 regressions before production in the first year.
  • Cut 75th percentile LCP on product pages from 3.4 s to 1.9 s, using Lighthouse CI, WebPageTest and real-user monitoring to find render-blocking scripts and oversized hero images.
T-Mobile Performance Engineer
Bellevue, WA • Jul 2018 to May 2022
  • Rewrote 140 LoadRunner scripts for the account and billing APIs in JMeter, running distributed tests on AWS and cutting test licence costs by $180K a year.
  • Found a connection pool leak in the app login service during 12-hour soak tests, ending weekly restarts and keeping the service up for 90 days straight.
  • Profiled the plan change service in Dynatrace before an iPhone launch weekend, removing 3 N+1 queries and raising sustained throughput to 2,400 transactions a second.

Done editing? Download a real PDF (selectable text, ATS-friendly, US Letter) or an editable Word file if a recruiter asks for one.

About this template

A Performance Engineer resume template, built by a tech recruiter.

Performance engineers answer one question for the business: how much traffic can this take, and how fast will it stay? You script load and stress tests in k6, JMeter or LoadRunner, profile whichever service slows down first, tune its database and garbage collector, and agree latency budgets with the teams that ship. Job ads also call it performance test engineer or software performance engineer, and at smaller companies it lives inside SRE or QA.

Most performance resumes that land in my inbox start with a row of load testing tools and the line "ran performance tests". All that proves is you’ve opened JMeter. It doesn’t say what the test found. Calls go to resumes that show p99 latency they cut, breaking points found before launch, regressions caught in CI, capacity planned for a peak and slow queries they fixed. Each one comes with its before and after.

Lukas’s Nordstrom job on this template covers that list in 8 bullets, from load test design through Core Web Vitals, so a performance hiring manager finds every area they check. Replace his systems and figures with yours. 6 steps to write a Performance Engineer resume follow the 3 examples.

Sending applications already? Put your resume in the upload box below this section and I’ll review your CV without charging you. I open every file myself and mark each bullet where a load test ran but its result never made the page.

Industry signal

What the market says about Performance Engineer roles

Is performance engineering still worth getting into in 2026? The tools say yes. In March, OpenTelemetry Profiles went into public Alpha, so continuous profiling now has an open standard next to traces and metrics. JDK 26 shipped the same month with faster G1 garbage collection. And retail keeps setting records: US shoppers spent $14.25 billion online on Cyber Monday 2025, per Adobe. Every one of those peak days needs someone who tested for it.

+6% US software QA and tester job growth to 2035 US Bureau of Labor Statistics
$131,235 Average base pay, US performance engineer ads Indeed

Resume Samples

Performance Engineer Resume Examples

A performance engineer at year 3 and one at year 11 shouldn’t have the same resume. Compare these 3 performance testing resume samples to see what shifts. The junior came to load testing at Zoom from back-end work, the senior owns latency on LinkedIn’s feed services, and the lead gets Disney Streaming ready for its biggest live events. You can download each one as a PDF or a Word file, free and with no signup.

Junior Performance Engineer Resume Example

A junior performance resume has to show you can run a test and read what it tells you: a k6 script you wrote, a hot spot you found with a profiler, a slow query you fixed with a senior watching. Back-end experience counts, so keep it on the page.

Years of experience
3 years (2 in performance)
Industry
Video communications
Stack
k6PythonDatadogPostgreSQL
Download PDF Download Word

Click to download the Junior Performance Engineer resume example as a PDF or a Word file. Free / No signup.

Ethan Brown

Junior Performance Engineer

San Jose, CA · ethan.brown@gmail.com · +1 408-555-0124 · linkedin.com/in/ethanbrown

Profile Summary

  • Junior Performance Engineer with 2 years load testing and profiling video meeting services, after a year as a back-end Python engineer on a marketplace listings API.
  • Writes load tests in k6 and Locust, profiles Python and Go services with py-spy and pprof, and reads latency in Datadog and Grafana on Kubernetes and AWS.
  • Learning workload modeling and capacity math from senior engineers, and reports p95 and p99 on every test instead of averages.
  • Works with platform, SRE and media teams in weekly test reviews, release readiness checks and the on-call shadow rotation.
  • Keeps the team’s k6 script library tidy, wrote the how to run a soak test page in Confluence, and pairs with new hires on their first test.

Technical Skills

Languages & Scripting:
Python, Go, JavaScript, SQL, Bash
Load Testing Tools:
k6, Locust, JMeter (basics)
Profilers & Runtime Tools:
py-spy, pprof, flame graphs, Chrome DevTools
APM & Observability:
Datadog, Grafana, Prometheus, OpenTelemetry (basics)
Databases & Caching:
PostgreSQL, Redis, EXPLAIN ANALYZE
Cloud, Containers & CI/CD:
AWS (EC2, EKS), Kubernetes, Docker, GitHub Actions
Front-End Performance Tools:
Lighthouse, WebPageTest, Core Web Vitals
Page 2 of 2

Work Experience

Zoom Performance Engineer I San Jose, CA · Aug 2024 to Present
  • Wrote k6 load tests for the meeting join API from a week of production request logs, holding a 1,200 requests per second baseline that the platform team now checks before each release.
  • Profiled the recording upload workers with py-spy and found a JSON serialization hot spot, cutting CPU use at steady load from 71% to 48%.
  • Tuned 6 slow PostgreSQL queries behind the meeting history page under a senior’s review, adding 2 indexes and bringing p95 query time from 620 ms to 140 ms.
  • Added a nightly k6 smoke test to GitHub Actions that fails when join latency rises over budget, catching 5 regressions before staging in its first 6 months.
  • Built p50, p95 and p99 latency panels in Datadog for 4 service teams and reported each one against its p99 budget weekly, keeping join latency in budget for 11 of 12 months.
eBay Software Engineer San Jose, CA · Jun 2023 to Jul 2024
  • Ran Lighthouse audits on the listing page and moved image resizing to the CDN, cutting 75th percentile LCP from 3.9 s to 2.4 s.
  • Wrote a Locust test for the search API before a holiday sale, which found a connection limit that capped it at 900 requests per second.
  • Planned the listings cache sizing for the sale with a senior engineer from a year of traffic data, so it kept up with 2.5x normal load.

Education

San Jose State University B.S. in Computer Science San Jose, CA · Aug 2019 to May 2023

Senior Performance Engineer Resume Example

At senior level I read a performance resume for ownership: the latency program you run, the profiling find that changed a service, the capacity call you made before a launch. Every claim needs a percentile and a before and after.

Years of experience
8 years
Industry
Professional networking
Stack
JavaGatlingOpenTelemetryKubernetes
Download PDF Download Word

Click to download the Senior Performance Engineer resume example as a PDF or a Word file. Free / No signup.

Naveen Iyer

Senior Performance Engineer

Sunnyvale, CA · naveen.iyer@gmail.com · +1 408-555-0162 · linkedin.com/in/naveeniyer

Profile Summary

  • Senior Performance Engineer with 8 years tuning feed, messaging and search services at consumer internet scale, specializing in JVM profiling, workload modeling and latency SLOs.
  • Hands-on with load testing (k6, Gatling), profiling (async-profiler, Java Flight Recorder), tracing (OpenTelemetry, Jaeger), data (MySQL, Couchbase, Apache Kafka) and Kubernetes.
  • Deep expertise in GC tuning, tail latency analysis, capacity forecasting and performance gates in CI, using the USE method to find the limit before traffic does.
  • Works with feed, SRE and infrastructure teams on launch reviews, postmortems and quarterly capacity planning.
  • Mentors 3 engineers on profiling, runs the weekly latency review for the feed org, and wrote 5 internal performance playbooks.

Technical Skills

Languages & Scripting:
Java, Python, Go, Scala, SQL, Bash
Load Testing Tools:
k6, Gatling, JMeter, Locust
Profilers & Runtime Tools:
async-profiler, Java Flight Recorder, pprof, Linux perf, G1 and ZGC tuning
APM & Observability:
OpenTelemetry, Jaeger, Grafana, Prometheus, InGraphs
Databases & Caching:
MySQL, Couchbase, Redis, Apache Kafka, EXPLAIN
Cloud, Containers & CI/CD:
Kubernetes, Docker, Azure, Jenkins, Terraform
Front-End Performance Tools:
Lighthouse, Chrome DevTools, Core Web Vitals, real-user monitoring
Page 2 of 2

Work Experience

LinkedIn Senior Software Engineer, Performance Sunnyvale, CA · Aug 2022 to Present
  • Profiled the feed ranking service with async-profiler and Java Flight Recorder, cut allocation in the scoring loop and moved it to ZGC, bringing p99 latency from 380 ms to 120 ms.
  • Built per-member workload models from 90 days of production traffic and replayed them in Gatling, finding a cache stampede at 4.1x peak before a major feed launch.
  • Set the Kubernetes CPU requests and autoscaling targets for 30 feed services from load test results, raising average utilization from 32% to 58%.
  • Added k6 benchmarks with latency thresholds to the Jenkins pipelines of 6 service teams, catching about three quarters of latency regressions before production.
  • Agreed p99 budgets for the feed API with product and SRE, with burn-rate alerts and a release review, and kept monthly SLO attainment above 99.5% for 2 years.
Yahoo Performance Engineer Sunnyvale, CA · Aug 2018 to Jul 2022
  • Instrumented the mail delivery back end with OpenTelemetry traces across 40 endpoints, cutting time to find the slow hop in an incident from 3 hours to 25 minutes.
  • Tuned MySQL read replicas and Redis caching for the search front end, cutting p95 on the hottest 28 queries from 1.4 s to 310 ms.
  • Cut LCP on the Mail web inbox from 3.1 s to 1.8 s by splitting the JavaScript bundle and preloading the first message list, measured in Lighthouse and real-user data.

Education

UC San Diego B.S. in Computer Science La Jolla, CA · Sep 2014 to Jun 2018

Lead Performance Engineer Resume Example

A lead performance resume is about the standard you set for other teams: the budgets they ship against, the tests that gate their releases, the peak events you signed off. Show the people you lead and the incidents that didn’t happen.

Years of experience
11 years
Industry
Video streaming
Stack
GatlingDynatraceApache CassandraAWS
Download PDF Download Word

Click to download the Lead Performance Engineer resume example as a PDF or a Word file. Free / No signup.

Solenn Marek

Lead Performance Engineer

Burbank, CA · solenn.marek@gmail.com · +1 818-555-0149 · linkedin.com/in/solennmarek

Profile Summary

  • Lead Performance Engineer with 11 years on video streaming platforms, leading playback latency and live event readiness for services with tens of millions of subscribers.
  • Hands-on with load testing (Gatling, k6, traffic replay), APM (Dynatrace, Datadog), profiling (async-profiler, pprof), data (Apache Cassandra, Amazon DynamoDB) and AWS.
  • Deep expertise in multi-CDN capacity models, per-event headroom planning, latency SLOs across teams and release gates, using Little’s Law to size what each event needs.
  • Works with playback, content delivery, SRE and product teams on event readiness reviews, design reviews and the incident bridge.
  • Leads 8 performance engineers across 4 squads, runs the platform performance guild, and wrote the org’s performance engineering career framework.

Technical Skills

Languages & Scripting:
Java, Go, Python, TypeScript, SQL
Load Testing Tools:
Gatling, k6, JMeter, Go traffic replay tools
Profilers & Runtime Tools:
async-profiler, Java Flight Recorder, pprof, eBPF
APM & Observability:
Dynatrace, Datadog, OpenTelemetry, Grafana
Databases & Caching:
Apache Cassandra, Amazon DynamoDB, PostgreSQL, Redis
Cloud, Containers & CI/CD:
AWS (EC2, EKS, CloudFront), Akamai, Fastly, Kubernetes, Jenkins
Front-End Performance Tools:
Lighthouse, WebPageTest, real-user monitoring, video start time metrics
Page 2 of 2

Work Experience

Disney Streaming Lead Performance Engineer Burbank, CA · Mar 2021 to Present
  • Lead 8 performance engineers across 4 playback squads, owning the latency SLOs and the readiness review for every live event, with 0 SEV1 incidents across 38 events.
  • Modeled CDN and origin capacity for 6 major live sports and premiere events with Little’s Law and past viewer curves, sizing each one for 5.2x normal traffic.
  • Replaced legacy JMeter rigs with Gatling and a Go traffic replay tool, retiring 120,000 lines of test code and cutting full test runs from 9 hours to 2.4 hours.
  • Ran the cross-squad playback start program with Dynatrace traces and video client metrics, cutting p99 time to first frame from 1.6 s to 480 ms.
  • Made latency checks a required gate in the Jenkins release pipelines of 5 product orgs, with budgets agreed in RFCs, blocking 47 slow releases in 2025.
Hulu Senior Performance Engineer Santa Monica, CA · Jul 2015 to Feb 2021
  • Profiled the recommendations API with async-profiler and fixed thread pool starvation, keeping p99 under 110 ms at 6,000 requests per second.
  • Tuned Apache Cassandra read paths for the watch history service, moving to a time-bucketed schema that cut p95 reads from 90 ms to 18 ms.
  • Cut home screen load time on smart TV apps from 4.8 s to 2.6 s by trimming image sizes and deferring rows below the fold, measured with real-user timing.

Education

UCLA B.S. in Computer Science Los Angeles, CA · Sep 2011 to Jun 2015

Free resume review

A recruiter screen, but with feedback

You applied to hundreds of jobs: no result. Companies won’t give you feedback, so you’re stuck in a loop. Rejections will keep coming until you know what’s wrong.

Let’s break this cycle today!

I’ll screen your resume the same way I did at Google.

You’ll get:

  • Your resume sections and content scored.
  • A clear list of what to improve, why, and how.
  • Behind the scenes secrets on the screening process.

How I rewrite Performance Engineer resumes

How to write a Performance Engineer resume

Emmanuel Gendre, ex-Google recruiter

Emmanuel Gendre Ex-Google recruiter, tech resume writer

Performance engineers puzzled me for 13 years of recruiting, and that includes many years at Google. Their whole job is measurement, yet theirs are the least measured resumes I read. I’ll see "conducted load testing using JMeter" on 3 jobs in a row, with no hint of what the test found or what got faster.

Clients of my technical resume services get questioned by me until those findings come out: the breaking point, the hot method in the flame graph, the p99 before and after. If you’re doing it yourself, though, focus on these 6 steps. Every step uses Lukas’s resume as its example.

  1. Step 1 Format & layout A single column and plain headings, sent as a parseable PDF. Go to step 1
  2. Step 2 Profile Summary Your level, test stack and strongest areas in 5 bullets. Go to step 2
  3. Step 3 Work Experience Lukas’s 8 Nordstrom bullets, one per performance competency. Go to step 3
  4. Step 4 Bullet Points One order service fix, grown from a plain task into a p99 result. Go to step 4
  5. Step 5 Technical Skills 7 skill rows from load tools to Core Web Vitals, plus soft skills. Go to step 5
  6. Step 6 Keywords & Metrics Tiered keywords, a JD checker and 3 metrics per area. Go to step 6

Step 1 · Format & Layout

Performance Engineer resume format and layout

Start with layout, since it’s a one-afternoon fix on a performance resume. Parsing software reads your file before any human does, and then a recruiter scans it for job titles, employers and dates. Keep the page plain and they’ll both find what they’re after.

01ATS Compliance

ATS compliance for your Performance Engineer resume

Nearly all the companies hiring performance engineers parse applications with an ATS (Applicant Tracking System) like Workday, Greenhouse or iCIMS. It sorts your file into fields: job title, employer, dates, skills. Later, a recruiter queries those fields for "JMeter" or "performance testing". When a layout trips up the parser, your load testing work can land in the wrong field or drop out of the results. For the mechanics, see how applicant tracking systems read resumes. Making your performance work show up in those queries comes down to 3 rules:

The 3 rules
  1. Use a 100% text based format (no Canva!)

  2. Avoid tables, pictures, and complex structures.

  3. Use the most predictable section names, like “Profile Summary” and “Work Experience”

02Design & Layout

Performance Engineer resume design and layout

A dark sidebar, a speedometer icon and a bar rating "JMeter 85%" still turn up on performance resumes I get. Google taught me this early on: recruiters hate fancy designs. Forty resumes into a screening day, no recruiter wants to dig through graphics to find where you work now.

Which is why this template stays boring and predictable. You get one column and one font, the section names every recruiter expects and nothing in the margins, so your latency figures get the attention. Prefer to start from a blank document? These are the specs I’d copy.

Layout Spec
Columns
One. No sidebars, tables, columns, pictures or tabs.
Margins
0.7 in on all four sides
Body size
10 to 11 pt
Type
One family, weight for hierarchy
Length
One page under 5 years, two after
Section order
Summary, Skills, Experience, Education
PDF

03File Format

Resume file format for your Performance Engineer resume

Default to PDF for a performance engineer resume. Parsers get clean text out of it, the layout holds on any laptop, and your p99 figures can’t get edited by accident. Only send .docx if the posting or an agency recruiter requests it, usually because they rebrand resumes. I’ve covered the other formats in my breakdown of resume file formats.

Format Guide
PDF
Your default. Layout holds, text stays selectable.
Word (.docx)
When the posting or a recruiter asks for it. Use the Word download above.
Plain text
For portals that make you paste into a box
Never
Images, scans, password-protected PDFs, shared-drive links
File name
Lukas-Reinhart-Performance-Engineer.pdf

Step 2 · Profile Summary

Performance Engineer profile summary

Put a summary at the very top of your performance resume, even with 1 year of experience. A recruiter screen has 2 rounds. Round 1 is quick and never gets past the first third of page 1: title, years, tools, the systems you test. If that part is fuzzy, round 2 doesn’t happen. Here’s what recruiters check in each screening round.

A performance hiring manager reads those 5 bullets with 3 questions in mind. Do you test, tune, or both? Have you seen real traffic at a real peak? Will product and SRE people take your word when you say a release isn’t ready? Lukas’s line under each bullet type shows how. If you’d like more on the section, my profile summary guide with examples goes deeper.

  1. 1

    Title, years and scope

    Target title first, then your years in performance work, the systems you test (checkout APIs, streaming, trading) and the traffic they carry. A recruiter shouldn’t need a second line to guess your level.

  2. 2

    Your stack

    Your load testing tools, profilers, APM, databases and cloud, each grouped under a label such as load testing (k6, JMeter). ATS keyword search tends to match this line first, so use the spelling from the job ad.

  3. 3

    Domain expertise

    The 4 performance areas you want your next job to be about, like workload modeling or GC tuning, plus the method you use and the result it brought. That’s how "knows JMeter" becomes "finds the bottleneck before Black Friday does".

  4. 4

    Collaboration

    The teams on your weekly calendar (service owners, SRE, DBAs, front-end) and where you sit with them: readiness reviews, peak rehearsals, latency incidents. A finding nobody acts on is wasted, and recruiters check for this.

  5. 5

    Leadership

    What the team gets from you besides results: a script library, a readiness checklist, engineers who now read flame graphs because you taught them. You don’t need reports for this. A hiring manager reads it as proof you’ll lift the people around you.

Performance Engineer resume summary example, from the template above
  • Senior Performance Engineer with 8 years of experience testing and tuning high-traffic retail and e-commerce platforms across web, mobile app and API traffic, specializing in load testing, JVM profiling and capacity planning.
  • Hands-on with load testing (k6, JMeter), profiling (async-profiler, Java Flight Recorder), APM (Datadog, OpenTelemetry), data (PostgreSQL, Redis) and cloud (AWS, Kubernetes).
  • Deep expertise in workload models from production traffic, p99 latency budgets, GC and query tuning and performance gates in CI, using the USE and RED methods to find the real bottleneck before a peak event.
  • Works closely with service owners, SRE, DBAs and front-end teams in release readiness reviews, peak rehearsals and latency incidents.
  • Mentors engineers on reading flame graphs and writing k6 scenarios, runs a monthly performance review with engineering leads, and wrote the team’s peak readiness checklist.

Step 3 · Work Experience

Performance Engineer work experience

Round 2 is the slow read, and it’s often the hiring manager reading this time. From my screening years, 95% of what they decide comes from your present role. It’s logical. What you do now is their best guess at your first 90 days with them.

That present role needs to cover the whole Performance Engineer role profile, meaning every area a hiring team scores you on. An area with no bullet gets read as one you’ve never done. Skip CI gates, and they’ll assume your tests only run when someone remembers. Here’s the order I’d use for all 8.

Performance Engineer role profile
  1. Load & Stress Test Design

    You build tests that push a system the way real users will. A test with made-up traffic doesn’t prove much, and most managers have watched a launch fall over after a green load test. Walk them through how you used production logs and k6 or LoadRunner scenarios to find the breaking point before customers did.

    Techniques
    workload modeling, soak and spike tests, breakpoint tests, distributed load generation
    Tools
    k6, JMeter, LoadRunner, Gatling, Locust
    Metrics
    peak load held, breaking point, throughput at the latency target, test coverage of key flows
  2. Profiling & Runtime Tuning

    You track a slow request down to the method that’s burning the time. This is the skill that separates a performance engineer from someone who only runs tests, and interviewers will ask you to read a flame graph live. Show how you used async-profiler or pprof and a GC change to cut latency or CPU.

    Techniques
    flame graphs, lock contention, GC and heap sizing, thread pools
    Tools
    async-profiler, Java Flight Recorder, pprof, py-spy, Linux perf
    Metrics
    p99 latency, CPU per request, GC pause time, memory per instance
  3. Capacity & Scalability Planning

    You work out what the system needs before the next big traffic day. Guess too low and the site goes down on Black Friday, guess too high and finance notices, so managers trust people who show the math. Explain how you used traffic forecasts and autoscaling targets to size a peak and what it cost.

    Techniques
    headroom modeling, Little’s Law, scalability tests, autoscaling targets
    Tools
    Python, Grafana, Kubernetes HPA, Karpenter, AWS Compute Optimizer
    Metrics
    peak traffic absorbed, headroom, cost per request, scaling incidents
  4. APM & Distributed Tracing

    You make it possible to follow one slow request through every service. In an incident, the team that finds the slow hop in minutes saves hours of guessing, and managers remember who set that up. Describe how you used OpenTelemetry and Datadog or Dynatrace so the next bottleneck took minutes to find, not hours.

    Techniques
    span instrumentation, RED and USE dashboards, percentile panels, trace sampling
    Tools
    OpenTelemetry, Datadog, Dynatrace, New Relic, Jaeger
    Metrics
    services traced, time to find the slow service, trace coverage, dashboard adoption
  5. Database & Query Tuning

    You get the database out of the way of a fast response. A missing index or an N+1 query is behind a big share of the slowdowns I hear about, and you’ll find it’s easy to prove with numbers. Point out how you used EXPLAIN ANALYZE and connection pool changes to cut query time on the paths users hit most.

    Techniques
    query plan analysis, index design, N+1 fixes, connection pool sizing, read caching
    Tools
    PostgreSQL, MySQL, Redis, PgBouncer, pg_stat_statements
    Metrics
    p95 query time, rows scanned, pool saturation, cache hit rate
  6. Performance Budgets & SLOs

    You agree with product and SRE on what fast means, in numbers. Without a budget, every test result turns into an argument, and teams ship whatever got through last time. Mention how you used p99 budgets and burn-rate alerts to hold teams to a latency target release after release.

    Techniques
    latency budgets per endpoint, SLI and SLO design, error budgets, release readiness reviews
    Tools
    Datadog SLOs, Grafana, Nobl9, Sloth, PagerDuty
    Metrics
    SLO attainment, endpoints with a budget, budget breaches, releases held back
  7. Performance Gates in CI/CD

    You test performance on every merge, not once a quarter. A regression caught in a pull request takes an hour to fix and the same one found in production can take a week, which hiring managers know well. Tell them how you used k6 thresholds or benchmarks in Jenkins or GitHub Actions to stop slow builds shipping.

    Techniques
    automated load tests, latency thresholds, benchmark baselines, trend reports
    Tools
    k6, Jenkins, GitHub Actions, GitLab CI, JMH
    Metrics
    regressions caught before production, services gated, gate run time, false alarms
  8. Front-End Performance & Core Web Vitals

    You make the page fast for the person holding the phone. Google uses Core Web Vitals in search ranking and retailers see conversion move with load time, so this is a number executives already watch. Detail how you used Lighthouse and real-user data to bring LCP or INP into the good range.

    Techniques
    render-blocking fixes, image and bundle weight cuts, code splitting, CDN caching
    Tools
    Lighthouse, WebPageTest, Chrome DevTools, CrUX, Datadog RUM
    Metrics
    LCP, INP, CLS, pages in the good range, JavaScript bytes

Moving into performance from QA, SRE or back-end work? Put the performance work you’ve already done under your current title, even one load test or one profiling fix, with its number. Hiring managers read what you did, not what the job was called.

Submit your resume for a free review!

Step 4 · Bullet Points

Performance Engineer resume bullet points

Bullets take up more of my rewrite time than every other section combined, and that’s why the Level System exists. Google’s XYZ formula was where it began. On top of it, I’ve layered what technical readers look for: technique, tools and method. You’ll find all of it in the Level System for resume bullet points.

Treat every level as a question about your own work and put the answer in the bullet. In performance work, the final answer is almost always a percentile, a throughput figure or a dollar amount. Below, one fix on a slow order service goes from 9 words to 46.

  1. Level 1Task

    What did I work on? Start with one fix you did yourself. As a plain task, it doesn’t tell a hiring manager how hard it was.

    Cut response times on the Nordstrom order routing service.

  2. Level 2+ Techniques

    How did I do it? Add the techniques. This is where a performance lead sees that you found the cause instead of adding servers.

    Cut response times on the Nordstrom order routing service by removing lock contention on a price cache and retuning heap settings.

  3. Level 3+ Tools

    What tools did I use? Put the real tool names in. A recruiter searches for "async-profiler", never for "profiling tools".

    Cut response times on the Nordstrom order routing service by removing lock contention on a price cache and retuning G1 heap settings on Java 21, found with async-profiler and Java Flight Recorder.

  4. Level 4+ Method

    What method did I follow? Say what started it. A fix that came out of a load test and a flame graph is one nobody second-guesses.

    Cut response times on the Nordstrom order routing service by removing lock contention on a price cache and retuning G1 heap settings on Java 21, found with async-profiler and Java Flight Recorder during a k6 peak rehearsal.

  5. Level 5+ Metric

    What was the result? End on the percentile that moved, with the before and after. That’s the line the interviewer will ask you about.

    Cut response times on the Nordstrom order routing service by removing lock contention on a price cache and retuning G1 heap settings on Java 21, found with async-profiler and Java Flight Recorder during a k6 peak rehearsal, taking p99 latency from 640 ms to 170 ms.

    1. 01 Task What you worked on
    2. 02 Techniques How you did it
    3. 03 Tools The stack you used
    4. 04 Method The method you followed
    5. 05 Metric The result, one number

Your numbers exist, because you ran the tests. Look in old k6 or JMeter reports, Datadog history, Grafana panels and the deck from the last readiness review before you draft anything. In the interview someone will want the source of every figure, and "our load test report" is a great answer.

Step 5 · Technical Skills

Performance Engineer resume skills

Skills in performance job ads fall into 7 buckets: languages, load testing tools, profilers, APM, databases, cloud and CI/CD, and front-end tools. Match the ad’s spelling exactly. When it says "LoadRunner Professional" or "Apache JMeter", write those words, because a recruiter’s ATS search uses the ad’s own terms.

Every skill in this section needs a bullet behind it. Listing Dynatrace with no Dynatrace work anywhere in your jobs raises a hiring manager’s eyebrow. Next come the 7 categories, Lukas’s completed rows, then 5 soft skills worth proving with numbers. Keywords get their own step next.

The 7 skill categories for a Performance Engineer resume

Most performance job ads include the starred tools, so I’d open each row with them. Versions only matter when the ad asks for one, like Java 21 or JMeter 5.6.

Languages & Scripting

Java and Python cover most performance work, since that’s what services and test harnesses are written in. Add Go, JavaScript or Scala when you profile or script in them, plus SQL and Bash.

JavaPythonGoJavaScriptTypeScriptSQLBashScala

Load Testing Tools

The tools you’ve written real scenarios in. Enterprise teams ask for LoadRunner and JMeter, product companies for k6, Gatling or Locust. Add BlazeMeter or NeoLoad when the ad mentions them.

k6JMeterLoadRunnerGatlingLocustNeoLoadBlazeMeter

Profilers & Runtime Tools

What you use to find where the time goes: async-profiler and Java Flight Recorder on the JVM, pprof for Go, py-spy for Python, Linux perf or eBPF lower down. GC tuning belongs here too.

async-profilerJava Flight Recorderpprofpy-spyLinux perfeBPFflame graphsGC tuning

APM & Observability

The commercial APM your teams live in (Datadog, Dynatrace, New Relic, AppDynamics) and the open tools around it, like OpenTelemetry, Grafana and Prometheus.

DatadogDynatraceNew RelicAppDynamicsOpenTelemetryGrafanaPrometheusJaeger

Databases & Caching

The databases you’ve tuned, not just queried. Add the tools you tune with, like EXPLAIN ANALYZE and PgBouncer, and the caches you’ve put in front of them.

PostgreSQLRedisMySQLOracleApache CassandraAmazon DynamoDBPgBouncerEXPLAIN ANALYZE

Cloud, Containers & CI/CD

Where your tests and services run, and the pipelines your performance gates live in: AWS or Azure, Kubernetes, Docker, Jenkins, GitHub Actions or GitLab CI.

AWSKubernetesDockerJenkinsGitHub ActionsGitLab CITerraformAzure

Front-End Performance Tools

Lab and field tools for page speed. You’ll want Lighthouse, WebPageTest and Chrome DevTools for lab runs, CrUX and real-user monitoring for field data, and Core Web Vitals as the target.

LighthouseCore Web VitalsWebPageTestChrome DevToolsCrUXDatadog RUMSpeedCurve

A finished Performance Engineer skills section

Technical Skills sample, from the template above
Languages & Scripting
Java, Python, Go, JavaScript, SQL, Bash
Load Testing Tools
k6, JMeter, Gatling, LoadRunner, Locust
Profilers & Runtime Tools
async-profiler, Java Flight Recorder, pprof, py-spy, Linux perf, G1 and ZGC tuning
APM & Observability
Datadog, OpenTelemetry, Dynatrace, Grafana, Prometheus
Databases & Caching
PostgreSQL, Redis, MySQL, PgBouncer, pg_stat_statements, EXPLAIN ANALYZE
Cloud, Containers & CI/CD
AWS, Kubernetes, Docker, GitHub Actions, Jenkins, Terraform
Front-End Performance Tools
Lighthouse, WebPageTest, Chrome DevTools, Core Web Vitals, Datadog RUM

Soft skills for a Performance Engineer resume

Nobody hires a performance engineer for being a "strong communicator". They hire the one whose test data stopped a bad release. Below are my 5 soft skills for this role, each with a bullet as proof.

  • Telling a team their release isn’t ready for peak

    Resume bulletShowed the checkout team a 3.1x peak test where p99 crossed 2 s, and they moved the launch a week to fix 2 slow queries first.

  • Walking service owners through a flame graph

    Resume bulletRan a monthly flame graph session for 20 back-end engineers across 5 teams, and 4 of their teams now profile before asking for more pods.

  • Pushing for test traffic that looks like production

    Resume bulletGot access to a month of anonymized access logs to rebuild the cart test mix, which found a cache miss storm the old test had missed for 2 years.

  • Staying calm on the day of a traffic peak

    Resume bulletLed the war room for the 2025 Anniversary Sale, ran 3 planned scale-ups from the capacity model, and closed the day with 0 customer-facing incidents.

  • Reporting a test result that went against the plan

    Resume bulletReported that a planned $400K hardware upgrade gave only 6% more throughput in testing, and the money went to fixing 3 hot queries instead.

Step 6 · Keywords & Metrics

Performance Engineer resume keywords and metrics

Before you send it, run 2 final checks. Keywords get you found. Type "LoadRunner" or "Dynatrace" into an ATS search and only resumes with those words come back. Metrics make you credible, because a performance engineer with no numbers on the page reads like one who skipped the test report.

Coming up are the performance keywords in 3 tiers, a checker for any posting you paste, and 24 metrics worked into example bullets.

+42%

Performance Engineer resume keywords, ranked

Tap any keyword for the phrasing job ads tend to use. You’ll see "performance testing", "load and stress testing" and "non-functional testing" for the same work, so put 2 of those phrasings on your resume.

Must-have

9

Put each one in your summary, a skills row and at least one bullet in your current job.

In a job description“Plan and run performance, load and stress tests for critical applications”

Strong supporting

9

List the ones you’ve really used in your skills rows and prove each one in a bullet.

In a job description“Experience with Gatling for high-volume load simulation”

Bonus

8

Add these only when the job ad asks for them and you’ve done the work.

In a job description“Instrument services with OpenTelemetry for distributed tracing”

Extract Performance Engineer keywords from a job description

Paste a performance engineer, performance test engineer or load testing job ad below. I’ll rank the tools, methods and metrics it asks for, so the gaps in your skills and bullets are easy to spot.

Must-have
Put these in your skills section and back each one with a bullet.
Strong supporting
Add the ones you’ve actually worked with. Skip the rest.

Nothing is uploaded: it all happens in your browser.

Metrics for a Performance Engineer resume

For every area of the role profile there are 3 metrics, and each sits inside a line from Lukas’s Nordstrom job. You’ll only need one per bullet.

MetricExample bullet
Load & stress tests
Peak load held Count The highest traffic the system took while staying inside its latency target.Ran the Anniversary Sale rehearsal in k6 at 3.5x normal peak, proving checkout held 4,800 orders a minute with p99 under budget.
Breaking points found Count Limits a test pushed past before real users could hit them.Built spike and soak tests for the cart and inventory APIs and found 4 breaking points before launch, each fixed and retested.
Peak multiplier tested Score How far above a normal day the test went, written as a multiple.Raised the standard pre-launch test from 2x to 3.5x normal peak after modeling Black Friday traffic from 2 years of logs.
Profiling & runtime tuning
p99 latency Time How long the slowest 1% of requests take, which is what users notice.Removed lock contention on a shared price cache in the order routing service, taking p99 latency from 640 ms to 170 ms.
CPU per request Percent Processor time a service needs for the same work before and after a fix.Found an object copy in the pricing hot path with async-profiler and removed it, cutting CPU per request by 34%.
GC pause time Time Time the JVM stops your code to collect garbage, usually at p99.Moved the inventory service from Parallel GC to G1 with resized heaps, cutting p99 GC pauses from 410 ms to 45 ms.
Capacity & scalability
Peak traffic absorbed Score Traffic on the biggest day compared with a normal one, handled without incidents.Sized EKS node groups and HPA targets from the capacity model, and the platform took 4.2x normal traffic on Black Friday with no scaling incident.
Headroom at peak Percent Spare capacity left when traffic was at its highest.Rebuilt the capacity model in Python from 2 years of sales forecasts and held 35% headroom through the whole holiday season.
Compute cost saved Money Spend cut by right-sizing from test data instead of guessing.Right-sized 30 over-provisioned services from load test results, cutting reserved compute by $310K a year.
APM & tracing
Time to find the slow service Time How long it takes in an incident to point at the service causing latency.Rolled out OpenTelemetry tracing in Datadog across 46 services, cutting time to find the slow service from 50 minutes to 9 minutes.
Services traced Count Services sending traces, so a request can be followed end to end.Took tracing from 12 services to 46 in 2 quarters, covering every hop in checkout and order flows.
Teams using the dashboards Count Teams that check the latency dashboards you built each week.Built RED dashboards per service in Datadog, now checked weekly by 14 product teams before each release.
Database & query tuning
p95 query time Time How long 95% of a query’s runs take, before and after tuning.Added covering indexes and PgBouncer pooling for the catalog’s top 25 PostgreSQL queries, cutting p95 from 1.2 s to 140 ms.
Cache hit rate Percent Share of reads served from cache instead of the database.Put a Redis read cache in front of product availability lookups, raising the hit rate to 94% and taking load off the primary.
Connection pool saturation Count Times the pool ran out of connections and requests had to wait.Resized connection pools across 9 services after a soak test, cutting pool exhaustion events from 40 a week to 0.
Budgets & SLOs
SLO attainment Percent Share of the time an endpoint stayed inside its latency target.Agreed p99 budgets with 14 product teams and SRE, raising monthly SLO attainment from 91% to 99.2%.
Endpoints with a budget Count Customer-facing endpoints with an agreed latency target.Wrote latency budgets for 32 customer-facing endpoints and added them to the release readiness review.
Releases held back Count Releases stopped at review because they broke an agreed budget.Held back 7 releases in a year that broke their p99 budget, each fixed and shipped within a week.
CI/CD performance gates
Regressions caught before production Count Slowdowns stopped by an automated check before release.Added k6 gates to the GitHub Actions pipelines of 22 services and caught 31 regressions before production in the first year.
Services gated Count Services whose pipelines run a performance check on every merge.Took performance gates from 3 pilot services to 22 in 6 months, with a shared k6 template for each team.
Gate run time Time How long the performance check adds to each build.Cut the CI performance check from 25 minutes to 6 minutes by running shorter tests on merge and full runs nightly.
Front-end and Core Web Vitals
LCP at the 75th percentile Time Largest Contentful Paint for real users, the main Core Web Vitals load metric.Removed render-blocking scripts and resized hero images on product pages, cutting 75th percentile LCP from 3.4 s to 1.9 s.
Pages with good Core Web Vitals Percent Share of page loads rated good on LCP, INP and CLS in field data.Raised the share of product page loads with good Core Web Vitals from 52% to 81% over 3 releases.
INP Time Interaction to Next Paint, how fast the page responds to a tap or click.Split long tasks in the cart page JavaScript, bringing INP at the 75th percentile from 380 ms to 160 ms.

What if you don’t have exact numbers?

  • 1

    Go back to the test reports. k6 and JMeter summaries, APM history, CI logs and readiness review slides usually still hold the before numbers you need.

  • 2

    Rounded is fine, invented isn’t. Writing "about 3x normal peak" is honest if a test run or a Grafana panel backs it up.

  • 3

    Missing a baseline? Give the scale. Services under test, endpoints with a budget, peak requests a second or the events you prepared for show how much you were responsible for.

Free resume review

A recruiter screen, but with feedback

You applied to hundreds of jobs: no result. Companies won’t give you feedback, so you’re stuck in a loop. Rejections will keep coming until you know what’s wrong.

Let’s break this cycle today!

I’ll screen your resume the same way I did at Google.

You’ll get:

  • Your resume sections and content scored.
  • A clear list of what to improve, why, and how.
  • Behind the scenes secrets on the screening process.

Frequently asked

Performance Engineer resume FAQ

It costs nothing, and you won’t have to sign up or hand over an email. Type your details into the side panel, export your PDF, and update it after each peak season while the test numbers are fresh.

Yes, it’s the Word button beside Download PDF. Ethan’s, Naveen’s and Solenn’s examples also come as .docx files. For direct applications, the PDF is what I’d send. The Word copy is for agency recruiters who edit or rebrand resumes before sending them to clients.

Yes. It uses one column and standard headings, and exports a text-based PDF that Workday, Greenhouse and other ATS tools parse cleanly. To check your edited copy, open the PDF, select everything, paste it into a blank note and make sure your jobs come out in order.

Under 5 years in performance work, aim for 1 page. With more, 2 pages is normal once you have load programs, tuning wins and peak events to describe. Recruiters skip vague lines, not long resumes, so delete "responsible for performance testing" long before a bullet carrying a p99.

Put the job ad’s tool first, and only list tools you’ve written real tests in. Banks and telecoms still post a lot of LoadRunner and JMeter work, while product companies lean toward k6, Gatling or Locust. If you know 2 well, say which one each bullet used.

Percentile latency (p95, p99), throughput at the latency target, breaking points, CPU or memory per request, query time, regressions caught in CI and Core Web Vitals like LCP. Always give a before and after, and say which percentile you mean. "Latency improved by 70%" with no percentile tells a hiring manager very little.

A performance resume is about speed and scale: load tests, profiling, capacity and latency budgets. A QA resume centers on test plans, defects and release quality, so compare it with the QA engineer resume template. An SDET resume leans on automation frameworks and code, like the SDET resume template with automation bullets. An SRE resume owns uptime, on-call and incidents, as in the site reliability engineer resume template.

Show the performance work you’ve done inside another role. A JMeter test you wrote as a QA engineer, a slow query you fixed as a back-end developer, or a k6 project on GitHub with a written report all count. Give each one a number and title the resume for the performance job you want.

No. Hiring managers judge what you tested, what you found and what got faster. Nobody rejects a resume because the layout looks familiar. What hurts is a resume full of "ran load tests" with no results, which is the gap this template was designed to close.

More resources

More help with your Performance Engineer resume