Salesforce development means writing custom code on the Salesforce platform when configuration and Flow are not enough.
Salesforce development services · Apex · Lightning Web Components · integrations · Agentforce actions
Your Apex is about to change behaviour. Salesforce development that survives the platform, not just the sprint
- Apex written for user mode. API version 67.0 makes database operations run in user mode by default and classes default to with sharing. Existing code keeps its old behavior until its API version is raised to 67.0, which is why this breaks months after the release rather than on the day
- Lightning Web Components for the screens configuration genuinely cannot reach, built accessible and tested, rather than as a way to avoid learning what Flow can already do
- Integrations that fail loudly. Retries, idempotency and alerting on External Client Apps and a supported API version. Platform API 31.0 to 40.0 retire in Summer 2028, and most orgs cannot currently say what is calling them
- Tests that assert. Seventy-five percent coverage is a deployment gate, not a quality measure. We have read orgs at ninety percent whose suites prove only that the code ran without throwing
Most Salesforce codebases were not designed, they accumulated. We write the code that genuinely needs to be code, argue you out of the code that does not, and leave something the next person can safely change.
Proven Success With
23+ salesforce certifications · 5.0 from 5 client reviews

















Watch: the 2-minute overview
Code your team can ship on a Friday
Whether it is code someone wrote years ago or your first line of custom code: how we decide what should be code at all, build it properly, test it for real and keep it safe to change.
Chapters
New to Salesforce development?
What is Salesforce development?
Apex is Salesforce’s server-side programming language. Lightning Web Components are the building blocks for custom screens.
Good development also covers integrations with other systems, automated tests, and a safe way to release changes.
Pressure we surface early
Nobody designed this codebase. It accumulated, one deadline at a time
What we find in an inherited org: several triggers on one object with business logic inside them, a class working around a governor limit nobody can explain, integrations pinned to a 2016 API version, and tests that prove the code ran rather than worked.

Code that assumes system mode
API 67.0 makes database operations run in user mode by default and classes default to with sharing. Any Apex quietly relying on reading or writing records the running user cannot see fails once its API version is raised to 67.0.
Several triggers on one object
Three trigger files on Opportunity, plus a Flow and a Process Builder, firing in an order nobody can reliably predict. Every change becomes a gamble, so eventually nobody makes one.
Coverage without assertions
Comfortably past the 75 percent deployment gate, with test methods that create a record, call a method and check nothing. The suite proves the code ran without throwing, which is not the same as working.
Callers on a retiring API version
Platform API 31.0 to 40.0 are deprecated in Summer 2027 and retire in Summer 2028. Most orgs can see the version in the usage reports and cannot say which system is behind it.
Code where configuration would do
Apex written to do what a validation rule or a Flow already does, usually because the previous partner was paid to write code. Salesforce upgrades configuration three times a year. You upgrade Apex forever.
Deployments that are an event
Change sets assembled by hand, a two-hour window, someone watching the log, and no rehearsed way back. Deployment should be the boring part, and when it is not, teams deploy less often and each release carries more risk.
How we write it
Six standards, and they are not negotiable per project
These are the rules the code is written to whether or not anybody is watching. They are unremarkable to a good engineer and they are exactly what is missing from most of the inherited codebases we are asked to read.
One trigger per object
Handler pattern · predictable orderA single trigger delegating to a handler, with logic in service classes. Order of execution becomes something you can read rather than something you discover during an incident.
Bulk-safe by construction
No queries in loops, everWritten for two hundred records because that is what a data load will send. Governor limits are a design constraint, not something to be discovered when someone imports a spreadsheet.
User mode unless stated
WITH USER_MODE · explicit sharingSharing declared explicitly on every class, elevation used deliberately and commented where it is genuinely needed. Code written this way was already correct before API 67.0 made it the default.
Tests that assert
Negative · bulk · permission casesPositive and negative paths, bulk cases, and tests that run as a user with realistic permissions rather than as an administrator. Coverage is a floor of 75 percent, never the goal.
Failures that are loud
Retries · idempotency · alertingNo empty catch blocks. Integrations retry safely, log usefully, and page somebody when they stop working, so a broken feed is found by us rather than by your customer.
Reviewed before merge
Human review · static analysisEvery change read by a second engineer and run through Salesforce Code Analyzer. The review is where design problems get caught, which is why it is not optional when the deadline is tight.
Scope of delivery
What we build, and what we will talk you out of
Across Apex, Lightning Web Components, the platform APIs, Agentforce actions and MuleSoft, scoped with a written estimate, a review standard, and a named engineer who stays on it after go-live.
Estimates are wrong. Estimates given without reading the existing code are not estimates, they are guesses with a number attached, and the difference always comes out of your budget rather than the partner's.

Technical assessment
An independent read of what exists: classes, triggers, LWC, integrations, jobs, tests and API versions in use, with findings ranked by what fails first. Yours to keep whether or not you continue with us.
Apex & platform logic
Triggers, service classes, batch and queueable jobs, invocable actions and platform events, written bulk-safe and correct under user mode.
Lightning Web Components
Custom interfaces where configuration genuinely cannot reach, built accessible and tested, with TypeScript where the project benefits from it.
Integrations & APIs
REST, platform events and middleware with retries, idempotency and alerting, built on External Client Apps and a supported API version rather than whatever was current when the last integration was written.
Legacy remediation
The API 67.0 user-mode work, replacement of WITH SECURITY_ENFORCED, and migration off platform API versions that retire in Summer 2028.
DevOps & release engineering
Source-tracked development, scratch orgs or sandboxes, a promotion path, static analysis in the pipeline, and deployments that are boring by design.
Agentforce actions
Apex invocable actions and the LWC surfaces around them, scoped so an agent can retrieve and draft freely and stops at a named approver for anything that commits. See Agentforce implementation.
Who we work with
Four people are in the room, and only one of them can read the code
That asymmetry is where most development relationships go wrong. The business cannot tell good work from work that merely runs, and the developer has no incentive to volunteer that half of it should have been configuration. We write for whichever of these you are. Tap a group to pre-scope the conversation form.

Builds
What people actually ask us to build
Six shapes cover most of it. What separates a build that ages well from one that becomes a liability is not the code, it is the four beats before and after it. Most requests survive the second beat in a smaller form than they arrived in.
- ReadThe existing code and data model, before anybody estimates anything
- ReduceWhat is configuration, what already exists, and what is not actually needed
- BuildTo the standard, with tests written alongside and a second engineer reviewing
- Hand overDocumented in your org and your repo, so the next person is not guessing
SynconAI build sequence. The second beat is the one that gets skipped everywhere else, and it is where most of the eventual maintenance cost is decided.
Complex logic Flow cannot carry
Pricing, allocation, entitlement or scheduling rules with real branching, running in bulk inside governor limits. This is what Apex is genuinely for, and it is a fraction of what Apex actually gets used for.
Integration with a system nobody supports
An ERP, a core banking platform, a warehouse system, or something written in-house fifteen years ago. Contracts, retries, idempotency and alerting, so a failure is an alert rather than a slowly diverging data set.
A screen the platform will not give you
A multi-step interface, a bespoke console, or a customer-facing page where the standard components genuinely do not fit. Built accessible and tested, not as an excuse to avoid learning what Lightning pages can do.
Agent actions that do real work
Apex invocable actions with a clear input and output contract, so an agent can retrieve, calculate and draft. Anything touching price, credit, access or contractual language stops at a named approver.
Rescue of a build that stalled
A partner left, a developer resigned, or the last release broke something nobody can find. Starts with reading it and telling you honestly how much is salvageable, which is sometimes less than you were hoping.
A managed package or AppExchange product
A different discipline from org development rather than the same work with a namespace on it. Packaging, API version pinning, upgrade paths and the security review shape the architecture from the first line, not from the submission.
Before anybody writes code
Three questions that decide whether this build ages well
None of these are technical. They are the ones that get skipped because the deadline is already set, and they are the reason a build that shipped on time becomes unmaintainable inside a year. They take days, not a discovery phase.
01. Does this need to be code?
Flow, validation rules, formula fields and permission sets are upgraded by Salesforce three times a year and can be changed by an administrator. Apex is upgraded by you, forever. We answer this honestly even when the answer costs us the build.
02. What does the data model have to be?
Everything downstream inherits it: the queries, the sharing, the reports, the integrations, and eventually what an agent can be grounded on. Getting it wrong is the one mistake that stays expensive no matter how good the code is.
03. Who changes this in two years?
An in-house admin, a different partner, or nobody. That answer changes what we build. Code written for a team that does not exist yet needs to be duller and better documented than code written for the person sitting next to you.
The most useful sentence a development partner can say is "you do not need us for this". It costs one invoice and it buys the only thing that makes the next ten conversations easy, which is being believed.

Reference architecture
Where a decision belongs, and what it costs to change later
Most architecture arguments are really about which layer something belongs in. Push every decision as far down as it will go, because changing it costs more the higher it sits. A permission is cheap. An integration contract is the most expensive thing here.
We design toward Salesforce Well-Architected outcomes, Trusted, Easy and Adaptable, and every assessment finding is written against one of these layers so it can be priced and sequenced rather than argued about in the abstract. Edition, licenses and release stage govern what is available to you; your account team and the release notes remain authoritative.
SynconAI decision model for development engagements. Aligns with Salesforce Architects diagrams language; your edition still governs what you can configure.
Cost of change, lowest first
Agent actions
An agent that only answers is a demo. Actions are where it becomes code
Retrieve, calculate and draft freely. Stop at a named approver for anything that commits
Grounding gets an Agentforce agent as far as answering questions. Doing work needs actions, and an action is Apex or Flow with a defined input and output contract. We build the invocable Apex and the Lightning Web Component surfaces around it, with the permission boundary decided deliberately rather than inherited: an agent sees what its running user can see, which is a very different question now that user mode is the default. The harder half is rarely the action itself. It is making the data underneath consistent enough that the action returns something true. Details on our Agentforce consulting page.

The action contract
Invocable Apex with typed inputs and outputs, a description an agent can reason about, and behavior that is the same every time it is called. Ambiguous contracts are where agents go wrong far more often than models do.
The permission boundary
An agent reads as its running user. Choosing that user, and the permission set behind it, is a security decision rather than a configuration detail, and it deserves the same review as any other access grant.
The stop
Price, credit, access and contractual language stop at a named approver. Drafting is where the value is; committing is where the exposure is, and the two should never be the same step.
Delivery method
How a development engagement runs
Six stages, and the first one is reading rather than building. Sponsors get an assessment, a written estimate based on it, a review standard the code is held to, and a named engineer who is still there after go-live. Same method as our broader Salesforce consulting practice.
Assess
Read what exists: classes, triggers, LWC, integrations, jobs, tests and API versions in use. Findings ranked by what fails first. This is where the estimate comes from, rather than from a conversation about scope.
Design
Decide what is configuration and what genuinely needs code, settle the data model, and push every decision as far down the stack as it will go. The cheapest change is the one that never became Apex.
Build
Apex and Lightning Web Components written to the standard: one trigger per object, bulk-safe, sharing declared, tests written alongside the code with assertions that would actually catch a regression.
Review
Read by a second engineer, run through Salesforce Code Analyzer, and checked for the things a linter cannot see: whether the design is right and whether the tests would fail if the code broke.
Ship
Promoted through the agreed path with a regression run and a rollback somebody has actually rehearsed. Deployment should be the boring part of the week, and when it is not, teams ship less and risk more.
Own
The engineers who wrote it stay on it: change backlog, integration monitoring and release testing. Optionally alongside managed services or ongoing Salesforce administration.
![]()
Cost and timing
What it costs and how long it takes
The review is free
A 60-minute architecture review of your Salesforce development setup, with a written plan you keep.
A fixed-scope proposal first
Before any work starts you get a written proposal: a fixed-scope project with milestones, or a monthly plan. You approve it, or you do not.
Timing follows scope
How long it takes depends on what is in scope. The proposal states the milestones, so you see the timeline before you commit.
Client reviews
What clients say about working with our architects
Verbatim reviews from SynconAI Salesforce, development and Agentforce engagements across the United States, Australia and globally. Anonymized clients are labeled by sector.
Salesforce Select Partner23+ Salesforce certificationsDelivery across USA, Sydney & India
Simply Outstanding
“SynconAI Consulting are Simply the Best in the Business When it comes to Salesforce implementation and AI-powered solutions, SynconAI are in a league of their own. Their expertise, dedication, and ability to deliver results that truly move the needle sets them apart from every other consulting partner we've worked with. What they achieved with our Sales Cloud, Service Cloud, and custom Agentforce agent has completely transformed how we operate streamlining our pipelines and our customer service, and automating tasks that used to consume hours of our team's time. They don't just implement technology they transform businesses. If you want the best, you work with their team.”
“I had a very urgent deadline for our project reporting to be delivered and needed to build the module, dashboard and output reports in Salesforce. SynconAI were very responsive - they met with me online, responded to my emails quickly and took calls - whatever was needed to progress the work quickly. We are thrilled with the outcome and will continue to work with SynconAI in the future to continue to build our Salesforce capability and platform.”
“The team at SynconAI were fantastic, and promptly delivered on each project. They were able to guide us through every stage and made sure we were satisfied with the outcomes on multiple scopes of work.”
“They have been great and helping us transform out business by bringing what I conceptualize to life. Great at translating process/workflow needs into a solution. Been a pleasure work with and they're a critical part of our team and will be instrumental into bringing about my vision.”
“Working with SynconAI was a seamless and highly professional experience from start to finish. They took the time to deeply understand our business processes before designing and implementing a Salesforce solution tailored specifically to our operational needs. The team demonstrated strong technical expertise across Salesforce configuration, automation, integrations, reporting, and user experience design.”
Read next
Our insights on Salesforce development
Analysis10 min
Flow or Apex: the criteria applied to ten real requirements
The Flow or Apex criteria applied to ten real requirements: where each one crosses into code, where volume moves the line, and where the honest answer is neither tool.
Operations11 min
A technical debt audit you can run on your own org
An ordered technical debt audit for a Salesforce org: what to inspect in each area, what a bad result actually looks like, and the question that decides whether the debt is worth paying down.
Engineering14 min
Salesforce API integrations that survive contact with production
The code-level and contract-level decisions behind a durable Salesforce integration: API family, authentication failure modes, limits as design constraint, idempotency, retries, partial failure and versioning.
Frequently asked questions
Salesforce development, answered.
Straight answers about the API 67.0 user-mode change, replacing WITH SECURITY_ENFORCED, retiring API versions, when code beats configuration, what test coverage really proves, and how we deploy. The USA and Australia.
API 67.0, shipped in Summer '26, makes Apex database operations run in user mode by default. SOQL, SOSL, DML and Database methods now enforce the running user's sharing rules, field-level security and object permissions, and classes with no sharing declaration default to with sharing instead of without sharing. Existing classes keep their old behaviour until they are recompiled at 67.0 or later. That is the trap: the break does not arrive on release day, it arrives months later when somebody edits an unrelated line and the class recompiles. Any Apex that quietly relied on system mode to read or write records the running user cannot see will start failing then.
WITH USER_MODE. The WITH SECURITY_ENFORCED clause is removed in API version 67.0 and later. WITH USER_MODE is a genuine improvement rather than a rename: it handles polymorphic fields correctly, and it returns the full set of access errors instead of stopping at the first one, which makes it far easier to work out what a user is actually missing. The migration is mechanical but it is not a blind find-and-replace, because some queries were relying on the old clause failing silently in ways the new one will not.
Platform API versions 31.0 through 40.0 are deprecated in Summer '27 and retire in Summer '28, across REST, SOAP and Bulk. After retirement those calls fail. The API Total Usage event and the legacy API usage reports in Setup will tell you what is calling which version, but they will not tell you which system is behind it, which is usually the hard part. We inventory the callers, trace each one to an owner, and sequence the upgrades so the noisy ones do not all land at once.
Almost always, and we will say so before quoting to build it. Flow, validation rules, formula fields and permission sets are upgraded by Salesforce three times a year and can be changed by an administrator. Apex is upgraded by you, forever. Code is the right answer for complex bulk logic, external integrations, transactional integrity, genuinely custom interfaces and anything with performance constraints Flow cannot meet. It is the wrong answer for most of what it gets used for, and a development partner whose only tool is code will never tell you that.
No, and the two are almost unrelated. Seventy-five percent is a deployment gate: Salesforce will not let you release without it. It measures which lines executed during a test run, not whether anything was checked. We regularly read orgs sitting near ninety percent coverage whose tests contain almost no assertions, so the suite proves the code ran without throwing rather than that it did the right thing. What we look for is assertions, negative cases, bulk cases and permission-boundary cases, and that last one matters far more now that user mode is the default.
Both. Alongside an in-house team we usually take the work that needs the most context or the most care: architecture review, the integration layer, the remediation backlog, and code review on everything before it merges. Taking over an inherited or offshore codebase starts with an independent read: what it does, what it depends on, where the risks are, and what will break first. You get that assessment as a document whether or not you continue with us.
Salesforce, Apex, Lightning Web Components, Agentforce and Data 360 are trademarks of Salesforce, Inc. SynconAI is an independent Salesforce consulting partner: we advise on licensing and work alongside your Salesforce account executive, and we design, build and run what goes on top of it. Product screenshots are reproduced for illustrative purposes; availability varies by edition and release, and your account team and the Salesforce release notes remain authoritative.
Free architect conversation
Talk to an architect, not a sales rep.
60 seconds to brief us. A certified architect replies within one business day.












