100 Action Verbs for Software Engineer Resumes (Organized by What You Actually Did)

Every resume advice article tells you to 'use strong action verbs.' Then they hand you an alphabetical list of 300 words — from 'Accelerated' to 'Yielded' — with no context, no examples, and no clue which ones actually apply to software engineering.

This page is different. These 100 verbs are organized by what you actually did as a software engineer. If you built a feature, there's a category for that. If you optimized a system, debugged a production outage, or mentored a junior engineer — there's a category for each. Every verb comes with an example bullet showing how it works in context on a real SWE resume.

Verbs for Building Features

Use these when you created something new — a feature, service, tool, or system that didn't exist before.

1. Built — Built a real-time collaborative editor using WebSockets and CRDTs, supporting 40 concurrent users per document with <100ms sync latency.
2. Developed — Developed a multi-tenant billing service in Go that processes $2.8M in monthly recurring revenue across 340 customer accounts.
3. Engineered — Engineered a distributed task queue using Redis Streams and Node.js workers, processing 1.2M async jobs/day with automatic retry and dead-letter routing.
4. Implemented — Implemented OAuth 2.0 + PKCE authentication flow with refresh token rotation, securing 280K user sessions across web and mobile clients.
5. Shipped — Shipped a cross-platform React Native app from zero to 85K MAU in 3 months, with offline-first sync and 4.7-star App Store rating.
6. Created — Created an internal CLI tool in Python that automates environment provisioning, reducing new-developer setup time from 4 hours to 15 minutes.
7. Launched — Launched a self-service analytics dashboard (React + D3.js) used by 200+ account managers, eliminating 15 hours/week of manual Excel reporting.
8. Constructed — Constructed a data ingestion pipeline using Kafka and Apache Flink, processing 2.8B events/day with exactly-once delivery guarantees.
9. Introduced — Introduced feature flags via LaunchDarkly across 14 microservices, enabling 3x faster experimentation cycles and instant rollback on regressions.
10. Prototyped — Prototyped a GPT-4-powered code review bot during a hackathon sprint that auto-comments on PRs — adopted by 3 teams after demo day.
11. Established — Established a shared React component library (45 components, Storybook docs, WCAG 2.1 AA) adopted across 4 product teams.
12. Authored — Authored a Terraform module for multi-region ECS deployments, reused across 8 services and reducing infrastructure setup from 3 days to 2 hours.

Verbs for Optimizing and Improving

Use these when you made something existing faster, cheaper, more reliable, or more efficient.

1. Optimized — Optimized 14 slow PostgreSQL queries via pg_stat_statements analysis, cutting average API response time from 800ms to 95ms on the product catalog endpoint.
2. Reduced — Reduced frontend bundle size from 2.4MB to 380KB through code splitting, tree shaking, and lazy-loading 14 route-level components.
3. Accelerated — Accelerated CI pipeline from 24 minutes to 7 minutes by parallelizing test suites, caching Docker layers, and removing redundant lint steps.
4. Streamlined — Streamlined the deployment process from a 14-step manual runbook to a single 'make deploy' command, cutting deploy time from 2 hours to 12 minutes.
5. Refactored — Refactored 18K lines of legacy PHP into typed TypeScript modules, increasing test coverage from 12% to 78% and reducing production incidents by 40%.
6. Improved — Improved platform uptime from 99.5% to 99.97% by architecting multi-region failover with AWS Route 53 and Aurora Global Database.
7. Enhanced — Enhanced search relevance by implementing hybrid BM25 + vector search (OpenSearch + pgvector), increasing click-through rate on search results by 28%.
8. Minimized — Minimized cold-start latency for 22 Lambda functions from 3.2s to 400ms by switching to SnapStart, reducing provisioned concurrency costs by $4.1K/month.
9. Consolidated — Consolidated 6 overlapping notification services into a unified event-driven system (SNS + SQS), reducing infrastructure costs by 35% and eliminating duplicate alerts.
10. Eliminated — Eliminated 4,200 lines of Redux boilerplate by migrating state management to React Query + Zustand, reducing state-related bugs by 60%.
11. Modernized — Modernized a jQuery/Bootstrap marketing site to Next.js with Tailwind CSS, improving Lighthouse score from 38 to 96 and reducing bounce rate by 22%.
12. Tuned — Tuned JVM garbage collection parameters for the order-processing service, reducing P99 latency spikes from 1.8s to 200ms during peak traffic.

Verbs for Leading and Mentoring

Use these when you drove outcomes through people — leading projects, mentoring engineers, or coordinating across teams.

1. Led — Led a 5-person team through a 3-month API platform migration (REST to GraphQL), coordinating with 4 consumer teams and shipping with zero breaking changes.
2. Mentored — Mentored 4 junior engineers through weekly 1:1s and code review, with 2 promoted to mid-level within 12 months.
3. Spearheaded — Spearheaded adoption of trunk-based development across the engineering org (32 developers), reducing merge conflicts by 70% and enabling daily releases.
4. Coordinated — Coordinated a cross-functional incident response for a 4-hour payment processing outage, managing communication across engineering, support, and executive stakeholders.
5. Directed — Directed the technical roadmap for the platform team (3 engineers), delivering 4 major infrastructure projects on schedule across 2 quarters.
6. Championed — Championed TypeScript adoption across 8 frontend repositories, leading migration workshops and creating a style guide — team-wide adoption within 3 months.
7. Facilitated — Facilitated weekly architecture review sessions for a 14-person engineering team, establishing RFC and ADR processes that improved cross-team alignment.
8. Supervised — Supervised 3 summer interns through full project lifecycles, from spec to deployment — all 3 received return offers.
9. Advocated — Advocated for and implemented an on-call rotation restructure, reducing per-engineer on-call burden from 1 week/month to 1 week/quarter while maintaining response SLAs.
10. Onboarded — Onboarded 8 new engineers using a 5-module curriculum covering the data pipeline stack (Airflow, dbt, Snowflake), reducing ramp-up time from 6 weeks to 3 weeks.

Verbs for Debugging and Fixing

Use these when you found and fixed problems — production incidents, bugs, performance regressions, or reliability issues.

1. Resolved — Resolved a memory leak in the WebSocket connection pool that caused cascading OOM kills, restoring service stability for 45K concurrent users.
2. Diagnosed — Diagnosed an intermittent 502 error pattern using distributed tracing (Jaeger), identifying a DNS TTL mismatch between ECS tasks and the internal load balancer.
3. Triaged — Triaged and resolved 86 Sentry error reports over 3 sprints, reducing client-side JavaScript errors from 2.4% to 0.3% of sessions.
4. Patched — Patched a critical SQL injection vulnerability in the search API within 4 hours of disclosure, deploying a fix to production with zero downtime.
5. Debugged — Debugged a race condition in the distributed lock implementation (Redis + Redlock) that caused double-charging on 0.02% of transactions, writing regression tests to prevent recurrence.
6. Investigated — Investigated a 3x latency spike on the checkout API using flame graphs and slow query logs, tracing root cause to an unindexed JOIN on a 12M-row table.
7. Mitigated — Mitigated a DDoS attack on the public API by implementing rate limiting (token bucket via Redis) and IP-based throttling, restoring normal traffic within 20 minutes.
8. Recovered — Recovered 48 hours of lost transaction data from WAL archives after an accidental table truncation, restoring full consistency with zero data loss.
9. Remediated — Remediated 340 WCAG 2.1 AA accessibility violations across 28 pages using axe-core and manual screen-reader testing, achieving full compliance before the Q3 audit.
10. Stabilized — Stabilized a flaky test suite (14% failure rate) by isolating database state per test, mocking external APIs, and fixing 23 timing-dependent assertions — achieving 99.8% pass rate.

Verbs for Designing Systems

Use these when you made architectural or design decisions — system design, API contracts, data models, or technical specifications.

1. Designed — Designed a multi-tenant data isolation architecture using PostgreSQL row-level security, supporting 500+ enterprise customers on shared infrastructure.
2. Architected — Architected an event-sourced order management system (Kafka + DynamoDB) handling 50K orders/day with full audit trail and point-in-time replay.
3. Modeled — Modeled a normalized schema for the permissions system (RBAC + ABAC hybrid) supporting 12 resource types and 8 role hierarchies across the platform.
4. Spec'd — Spec'd the API contract (OpenAPI 3.1) for a new partner integration layer, defining 23 endpoints, authentication flows, and rate limiting policies adopted by 6 external partners.
5. Planned — Planned a phased database migration from MongoDB to PostgreSQL (18 collections, 2.4TB), executing over 4 months with continuous dual-write verification.
6. Defined — Defined SLOs for 8 critical services (availability, latency, error rate) and built SLI dashboards in Grafana, establishing the team's first formal reliability targets.
7. Evaluated — Evaluated 4 message queue solutions (Kafka, RabbitMQ, SQS, Pulsar) through load testing and cost analysis, selecting Kafka and documenting the ADR for future reference.
8. Diagrammed — Diagrammed the end-to-end data flow for the ML feature pipeline (Airflow → Spark → Feature Store → Model Serving) as part of a system design review for SOC 2 compliance.
9. Mapped — Mapped the service dependency graph for 26 microservices using distributed tracing data, identifying 4 circular dependencies and proposing a decoupling strategy.
10. Standardized — Standardized API error responses across 14 services to RFC 7807 format, reducing frontend error-handling code by 40% and improving Sentry alert grouping.

Verbs for Data and Analysis

Use these when you measured, analyzed, or instrumented systems to drive decisions with data.

1. Analyzed — Analyzed 3 years of deployment data (1,400 deploys) to identify failure patterns, leading to automated canary checks that reduced rollback rate from 15% to 2%.
2. Measured — Measured the impact of server-side rendering migration using Core Web Vitals, documenting a 62% LCP improvement and 34% FID reduction across 40 pages.
3. Instrumented — Instrumented 8 critical user flows with custom OpenTelemetry spans, enabling the first end-to-end latency visibility across the checkout pipeline.
4. Benchmarked — Benchmarked 3 serialization formats (JSON, Protobuf, MessagePack) for the inter-service communication layer, selecting Protobuf for 4x throughput improvement.
5. Profiled — Profiled the recommendation engine using py-spy and identified a quadratic loop in the scoring function, reducing computation time from 12s to 180ms per request.
6. Quantified — Quantified technical debt impact by correlating Jira bug tickets with code complexity metrics (cyclomatic, cognitive), building a prioritized refactoring roadmap.
7. Tracked — Tracked feature adoption via Mixpanel event funnels, identifying a 42% drop-off at the workspace creation step — led to a UX redesign that recovered 28% of lost users.
8. Audited — Audited IAM permissions across a 12-account AWS organization, removing 340 unused roles and 1,200 overly-permissive policies to meet SOC 2 least-privilege requirements.
9. Surveyed — Surveyed 45 engineers on CI/CD pain points, synthesized results into 5 improvement proposals, and delivered 3 within the quarter — raising developer satisfaction score from 3.2 to 4.1.
10. Validated — Validated the A/B test results for a new search ranking algorithm using Bayesian analysis, confirming a statistically significant 12% improvement in conversion rate.

Verbs for Automation and DevOps

Use these when you automated processes, managed infrastructure, or improved the development and deployment lifecycle.

1. Automated — Automated database backup verification by writing a nightly Lambda that restores snapshots to a test cluster, validates checksums, and alerts on failures — achieving verifiable 15-minute RPO.
2. Configured — Configured Datadog APM across 18 services with custom dashboards, alert thresholds, and PagerDuty routing — reducing mean time to detection from 38 minutes to under 3 minutes.
3. Deployed — Deployed a blue-green release system on ECS Fargate with automated canary analysis, enabling zero-downtime deployments and reducing rollback rate from 15% to 2%.
4. Containerized — Containerized 18 microservices with multi-stage Docker builds and deployed on EKS with Helm charts, reducing image sizes by 60% and enabling auto-scaling under 3x traffic spikes.
5. Orchestrated — Orchestrated a multi-stage data pipeline using Airflow (45 DAGs, 200+ tasks), processing 500GB of clickstream data nightly for the analytics warehouse.
6. Provisioned — Provisioned a multi-region Kubernetes cluster (3 regions, 120 pods) using Terraform and ArgoCD, with automated failover tested via monthly chaos engineering exercises.
7. Migrated — Migrated 140+ AWS resources from ClickOps to Terraform with remote state and Atlantis-based plan/apply, eliminating configuration drift across 3 environments.
8. Scripted — Scripted a secrets rotation system using AWS Secrets Manager and custom Lambda triggers, rotating 60+ database and API credentials quarterly with zero application downtime.
9. Integrated — Integrated SonarQube and Snyk into the CI pipeline across 24 repos, blocking PRs with critical vulnerabilities — catching 12 high-severity issues in the first month.
10. Monitored — Monitored a PostgreSQL cluster (3.2TB, 400K queries/hour) with custom pg_stat dashboards, proactively identifying and resolving 6 slow-query regressions before they impacted users.

Verbs You Should Stop Using

These verbs appear on thousands of SWE resumes. They all share the same problem: they describe proximity to work rather than ownership of outcomes.

1. Helped — 'Helped improve system performance' → Who actually improved it? What did you do? Replace with the specific action: 'Profiled and optimized 8 slow database queries.'
2. Assisted — 'Assisted the team with migration' → This says you were present. Replace with your contribution: 'Wrote migration scripts for 12 services and validated data integrity post-cutover.'
3. Worked on — 'Worked on the payments system' → This is a job description, not an accomplishment. Replace with what you built or changed: 'Integrated Stripe Connect for marketplace payouts across 3 currencies.'
4. Responsible for — 'Responsible for maintaining CI/CD pipelines' → This describes your job title. Replace with what you actually did: 'Reduced CI build time from 24 to 7 minutes by parallelizing test suites and caching Docker layers.'
5. Utilized — 'Utilized React and Node.js' → 'Utilized' is just a fancy word for 'used.' Don't tell people what tools you used — tell them what you built with those tools.
6. Participated in — 'Participated in code reviews' → Everyone participates. Replace with impact: 'Reviewed 200+ PRs across 3 teams, creating 5 shared ESLint rules based on recurring patterns.'
7. Collaborated with — 'Collaborated with cross-functional teams' → Only use this if you specify what the collaboration produced: 'Collaborated with the design team to redesign the onboarding flow, increasing 7-day activation from 23% to 41%.'
8. Supported — 'Supported production systems' → Replace with how: 'Maintained 99.97% uptime for 12 production services by implementing automated failover and runbook-driven incident response.'

How to Pick the Right Verb for Your Bullet

If you're staring at a bullet and can't find the right verb, use this decision framework:

• Did you create something new? → Use building verbs: Built, Developed, Engineered, Implemented, Shipped
• Did you make something better? → Use optimization verbs: Optimized, Reduced, Accelerated, Streamlined, Refactored
• Did you fix something broken? → Use debugging verbs: Resolved, Diagnosed, Triaged, Patched, Debugged
• Did you make a design decision? → Use design verbs: Designed, Architected, Modeled, Spec'd, Defined
• Did you drive outcomes through people? → Use leadership verbs: Led, Mentored, Coordinated, Championed, Directed
• Did you measure or analyze? → Use data verbs: Analyzed, Measured, Instrumented, Benchmarked, Profiled
• Did you automate or deploy? → Use DevOps verbs: Automated, Deployed, Containerized, Provisioned, Migrated

If you can't find a strong verb for your bullet, the problem usually isn't the verb — it's the bullet itself. A bullet that starts with 'Helped' or 'Worked on' is usually describing a responsibility, not an accomplishment. Rewrite the bullet to focus on a specific outcome, and the right verb will follow.

Your Verbs Are Only as Strong as Your Bullets

A strong verb can't save a vague bullet. 'Architected various backend systems' has a great verb and says nothing. The verb is the first word — but the rest of the sentence needs specific scope, technical detail, and measurable impact to actually work.

Rejectless checks everything — not just verb choice, but scope, metrics, defensibility, and the overall structure of every bullet on your resume. It's the same filter used in the examples above.

Frequently Asked Questions

How many different action verbs should I use on my resume?

Aim for variety across your bullets — repeating 'Built' 8 times makes your experience sound one-dimensional. A typical SWE resume has 12-15 bullets, so use at least 8-10 different verbs. That said, don't force obscure verbs for variety. 'Built' and 'Implemented' are fine to use once each.

Are these verbs ATS-friendly?

Yes. ATS systems parse resume text for keywords, and action verbs are standard resume language that every parser handles correctly. No ATS will reject your resume because of the verb you chose. Focus on matching the technical keywords in the job description — that's what ATS scoring actually evaluates.

Should I use the same verbs as the job description?

Mirror technical keywords (languages, frameworks, tools) from the job description — those matter for ATS keyword matching. But for action verbs, use whatever most accurately describes what you did. No recruiter compares your verb choices to the job posting.

More Guides