Salesforce developer CVs share a failure mode with the Trailhead platform that most Salesforce developers learn on: Trailhead teaches you how Apex and LWC work in sandboxes with small, clean data sets, where governor limits rarely fire and the same query can be written ten different ways without consequences. Production Salesforce orgs are nothing like this. With 500,000 records in an object, a SOQL query inside a loop hits the 100-query governor limit on the third trigger execution and locks out 200 sales reps. The batch Apex job that worked fine on 2,000 records in staging fails on 180,000 records in production. A Salesforce developer CV that doesn't show governor limit awareness — which means showing that the candidate designed for real data volumes from the start, used bulkified patterns, and structured integrations to stay within transaction limits — looks like a developer who built Trailhead projects and hasn't been in a real production org. The second critical omission is certification: in the Salesforce ecosystem, Platform Developer I is the standard professional credential for Apex and LWC developers, and a CV that doesn't name it in the headline hasn't used the primary shortlist signal available to it. This guide covers the Apex, LWC, and DevOps vocabulary that moves Salesforce developer CVs past ATS, and the production-quality signals that prove real platform experience.

What Salesforce Developer Job Descriptions Require in 2026

Salesforce developer JDs have a consistent set of technical requirements, with variation at senior and integration-specialist levels:

  • Apex development — the primary technical requirement. Apex is Salesforce's proprietary server-side language (Java-like syntax, compiled and executed on Salesforce's multitenant platform). Required depth: writing and maintaining Apex triggers (designed as bulkified, collection-aware handlers — never writing singleton trigger logic), Apex classes with proper separation of concerns, batch Apex for asynchronous processing of large data sets, queueable Apex for chained async processing, and schedulable Apex for time-based execution. Test class authorship is mandatory — Salesforce requires 75% code coverage across all Apex to deploy to production, and senior JDs expect meaningful tests with proper test data setup, mock callouts, and edge case coverage.
  • LWC (Lightning Web Components) — the modern Salesforce UI framework. Required depth: building functional LWC components using wire adapters (for reactive data binding to Salesforce data), custom events for component communication, Lightning Data Service (LDS) for standard CRUD without Apex, navigation service, and understanding of the LWC component lifecycle. Legacy Aura and Visualforce knowledge is useful for maintaining existing code but is not expected as primary expertise for new implementations.
  • SOQL and governor limit design — the most important practical skill for production Salesforce development, and the one most underrepresented on CVs. SOQL (Salesforce Object Query Language) is used to query Salesforce data. Governor limits constrain every Salesforce transaction: 100 SOQL queries per synchronous context, 150 DML statements, 10MB heap size, 10 seconds CPU time. Designing around these limits requires writing bulkified code (processing records in collections, never in individual loops), using relationship queries to reduce SOQL calls, and selecting asynchronous execution contexts (batch, queueable) when synchronous limits would be exceeded.
  • Integration — REST API (inbound and outbound), Bulk API 2.0 for large data volumes, Streaming API and Platform Events for event-driven integration, Named Credentials for secure endpoint configuration, and Connected Apps for OAuth. Integration requirements appear in the majority of senior Salesforce developer JDs.
  • Salesforce DX and DevOps — source-driven development (vs. org-based change sets), scratch orgs, unlocked packages, metadata deployment, and CI/CD integration (GitHub Actions, Bitbucket Pipelines, Copado, Gearset). Senior JDs increasingly require Salesforce DX experience as table stakes.

Salesforce developer salaries in 2026: £50K–£80K UK; £75K–£110K for senior and integration-specialist developers. US: $100K–$155K; $130K–$190K for platform-level architects and integration specialists.

ATS Keywords for a Salesforce Developer Resume

Salesforce developer ATS filtering uses Apex keyword names, LWC framework terms, certification codes, and integration protocol names. "Salesforce development" as a generic string is weaker than specific Apex pattern names and certification identifiers.

Essential ATS terms for a Salesforce developer resume:

  • Title variants: Salesforce Developer, SFDC Developer, Apex Developer, LWC Developer, Lightning Developer, Salesforce Platform Developer, Salesforce Engineer, Full Stack Salesforce Developer
  • Apex: Apex, Apex triggers, Apex classes, batch Apex, queueable Apex, schedulable Apex, future methods, test classes, @isTest, code coverage, TestDataFactory, mock callouts, HttpCalloutMock
  • LWC and UI: LWC, Lightning Web Components, wire adapter, Lightning Data Service, LDS, navigation service, Aura (legacy), Visualforce (legacy), SLDS, Salesforce Lightning Design System
  • Query and data: SOQL, SOSL, DML, governor limits, bulkification, heap size, CPU time, query optimisation, relationship queries, aggregate functions
  • Integration: REST API, SOAP API, Bulk API, Bulk API 2.0, Streaming API, Platform Events, Named Credentials, Connected Apps, OAuth, JWT, HTTP callout, MuleSoft
  • DevOps: Salesforce DX, SFDX, scratch org, unlocked packages, managed packages, Gearset, Copado, change sets, metadata API, GitHub Actions, CI/CD, deployment
  • Certifications: Salesforce Platform Developer I, PDI, Platform Developer II, PDII, JavaScript Developer I, Salesforce certified developer, Salesforce Architect (integration track)
  • Testing: unit test, @isTest, test coverage, 75% code coverage, mock, stub, Test.startTest, Test.stopTest
  • Long-tail phrases: Salesforce developer resume, how to write a Salesforce developer resume, Apex developer cv, LWC developer resume, SFDC developer resume, Platform Developer I resume, Salesforce integration developer resume

Placement: "Platform Developer I" (or II) in the headline — this is the standard professional credential for Apex/LWC developers and the primary ATS and recruiter filter. "Governor limits" or "bulkified Apex" anywhere in your experience bullets — this is the signal that proves production experience over tutorial completion. "Salesforce DX" and your CI/CD tooling (Gearset, Copado, or GitHub Actions) explicitly named in Skills.

Salesforce Developer CV Structure and Bullets That Prove Production Platform Experience

Section order:

  1. Headline — "Salesforce Developer | PDI · Apex · LWC · Salesforce DX · REST API Integration"
  2. Certifications — Platform Developer I/II with date (Salesforce certs have a maintenance window — expired certs are noted); near top, before Experience
  3. Skills — Apex Development / LWC & UI / Data & SOQL / Integration / DevOps & DX / Testing
  4. Experience — 4–5 bullets per role; org scale (record counts, user volume), governor limit design approach, and business outcome per bullet
  5. Projects — AppExchange apps, open-source Salesforce packages, significant GitHub repos with Salesforce DX structure

Two pages for 4+ years. Every Apex bullet should name the async pattern used (batch, queueable, schedulable) and evidence governor limit awareness. Integration bullets should name the API type and volume handled.

Three elements make a Salesforce developer bullet convincing: the org scale context (record volumes, user count, org complexity), the Apex/LWC implementation approach (pattern used, governor limit design choice), and the measurable outcome (integration accuracy, sync latency, page load improvement, deployment time reduction). Three examples:

  • Built an Apex integration layer to sync 180,000 opportunity and contact records between Salesforce and a SAP ERP via REST API — designed as a bulkified queueable chain (8 jobs, 25,000 records per job) to remain within governor limits on nightly batch runs; achieved 99.97% sync accuracy across 6 months of production operation, with automated error logging and Slack notification routing for any failed record batch
  • Developed 6 custom LWC components for a financial services client's agent portal, replacing 4 legacy Visualforce pages and 2 Aura components — reduced average portal page load from 4.2 seconds to 1.1 seconds through Lightning Data Service wire adapter caching; reduced Apex server callouts per agent session by 68% by caching commonly accessed reference data at the LWC component level
  • Migrated a 3-org Salesforce environment from change set-based deployment to Salesforce DX with an unlocked package architecture — built a GitHub Actions CI/CD pipeline that runs the 340-test Apex suite on every pull request, deploys to a named scratch org for integration validation, and promotes through UAT to production automatically; total deployment cycle reduced from 4 days to 2 hours

Salesforce developer interviews include live Apex challenges (bulkify this trigger, find the governor limit issue in this code, write a test class for this method), system design questions (design an integration between Salesforce and this external system), and debugging scenarios (this deployment failed with these errors — what do you do). Your CV's governor limit awareness and production org experience language determines whether the interview is pitched at senior design or at basic syntax.

Three Salesforce Developer CV Mistakes That Signal Trailhead Experience, Not Production Experience

No governor limit awareness anywhere in the CV. Governor limits are the single most production-distinguishing technical concept in Salesforce development. A developer who learned Apex on Trailhead sandbox modules has never encountered a production governor limit exception caused by a SOQL query inside a for loop processing 3,000 records. A developer who has worked in production orgs with real data volumes has almost certainly hit limit exceptions, diagnosed them, and refactored the code to handle collections properly. The difference is visible in the vocabulary: "bulkified trigger handler", "SOQL outside of loop", "queueable chain for large data volumes", "async processing via batch Apex" all signal governor limit awareness. Their absence — particularly on a senior Salesforce developer CV — suggests the candidate hasn't been in an org where these limits matter.

Test coverage claimed as a number without methodology. "95% code coverage" sounds good and means nothing without context. Salesforce's minimum is 75%, and it is possible to hit 75% coverage by writing System.assert(true) in a test class that calls the method once with a single record. Professional test coverage means: test data created by a TestDataFactory class (not SOQL in tests), separate test methods for positive path, negative path, and bulk data scenarios, mock callout implementations for external API tests, and assertions that verify specific outcomes not just execution without exceptions. If you write meaningful tests, describe the pattern: "wrote TestDataFactory-based Apex tests covering positive, negative, and bulk (200-record) scenarios with 94% coverage across 340 test methods" is a quality signal. A percentage number alone is not.

Certification absent or listed without the formal name. "Salesforce certified" and "Salesforce Platform Developer I" are not equivalent signals in ATS filtering or recruiter scanning. Platform Developer I (PDI) is the specific certification identifier that Salesforce ecosystem recruiters search for. A CV that says "Salesforce certified" or "passed Salesforce developer exam" without the full title will miss ATS filters that look for "Platform Developer I" or "PDI" as exact strings. Write the full certification name — Salesforce Certified Platform Developer I — and include the year it was achieved and the last maintenance completion date (Salesforce certifications require annual maintenance). The credential in full, in the headline, is the primary shortlist signal for Salesforce developer roles.

If you are applying to Salesforce developer or Apex engineer roles and want your CV rebuilt around the specific governor limits, LWC, and Salesforce DX requirements in a target job description, Resumegpt generates your Salesforce developer CV from your work history in under 60 seconds — production Apex depth evidenced, certification foregrounded, DevOps maturity signalled, ATS-optimised, and exported as a PDF ready to submit.