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 behaviour until it recompiles, 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.

  • Config first, code when it earns it
  • Every line reviewed before merge
  • Rollback rehearsed, not theorised

Proven Success With

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.

A developer reading through a long file of code on a large monitor.
Pressure point: every one of these was a reasonable decision under a deadline. The cost is not that any single one was wrong, it is that nobody can now change anything without discovering what else it touches.Photo: Pexels.
Apex

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 the moment it recompiles.

Order of execution

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.

Testing

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.

Integration

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.

Scope

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.

Release

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.

See where we would start

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 order

A 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, ever

Written 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 sharing

Sharing 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 cases

Positive 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 · alerting

No 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 analysis

Every 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 your build

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.

A record-triggered flow on the Flow Builder canvas beside an editor showing a versioned YAML specification file.
What run-state looks like: the declarative half and the source half of the same change, both under version control, both reviewable. When only one of them is in the repository, the other one is the part that breaks.Screenshot © Salesforce; product UI varies by edition and release. See Agentforce developer tools.

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 services.

Book a technical review

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.

An open-plan engineering team working across desks and monitors.
Operating cue: the most valuable thing a development partner does is occasionally refuse the work. If nobody has ever told you that a request should be a Flow, you are being sold hours rather than outcomes.Photo: Pexels.

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.

  1. ReadThe existing code and data model, before anybody estimates anything
  2. ReduceWhat is configuration, what already exists, and what is not actually needed
  3. BuildTo the standard, with tests written alongside and a second engineer reviewing
  4. 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.

Tell us what you need built

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.

Three colleagues working through a technical decision together at a desk.
Where the money is saved: not in typing faster, but in the conversation that removes a third of the scope before anyone estimates it. This is also the conversation a partner paid by the hour has no reason to start.Photo: Pexels.

See the full six-step delivery method

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, licences 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.

Partnership criteria

Why teams hand us the codebase

Offshore shops sell hours and will build whatever is asked for. Contract developers sell a person and leave with the context. SynconAI sells architect-led development: a written standard the code is held to, a second engineer on every change, and the willingness to tell you when a request should not be built at all. Learn more about our Salesforce consulting partner approach.

We will refuse work

Config first

If a validation rule and a Flow will do it, we will say so before quoting to build it. That costs us the invoice and it is the only reliable signal you have that the advice is worth anything.

We read before we quote

No guesses with a number on

An estimate given without reading the existing code is a guess, and the gap always comes out of your budget rather than ours. Assessment first, and you keep the findings either way.

A second engineer on everything

Review is not optional

Every change is read by someone who did not write it, and run through static analysis, including on the week the deadline is tight. That week is exactly when the worst code gets written.

The authors stay on it

No handoff to a queue

The people who designed it support it. Intent is most of what makes code changeable, and it is the first thing lost when a build is handed to a support pool that never saw the decisions.

You own the code and the pipeline

Your repo, your org

Source in your repository, the pipeline in your tooling, and documentation in your org. Leaving should be a transition rather than a hostage negotiation, and knowing that is what keeps a partner honest.

Delivery geography

AU · US

The United States and Australia hubs running the same code standard, the same review requirement and the same release discipline, with local commercial follow-up.

Book a technical review

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 services page.

An Agentforce agent definition form with role and agent-user settings, beside an editor showing the agent role file.
Where the boundary is set: the agent user and the permissions assigned to it decide everything the agent can reach. That is a security decision made on a form, reviewed like any other access grant, and it is the half of an Agentforce build that has nothing to do with prompting.Screenshot © Salesforce; product UI varies by edition and release. See Agentforce.

The action contract

Invocable Apex with typed inputs and outputs, a description an agent can reason about, and behaviour 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.

Delivery cycle: Assess · Design · Build · Review · Ship · Own

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. Own

    The engineers who wrote it stay on it: change backlog, integration monitoring and release testing. Optionally alongside managed services or ongoing Salesforce administration.

Salesforce Partner

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. Anonymised clients are labelled by sector.

5.0 average · 5 client reviews

 Salesforce Select Partner16+ architect 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.”

Sales CloudService CloudAgentforce
Jack BennettConsumer Goods & Retail · United States

“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.”

Sales CloudService CloudNonprofit Cloud
Salesforce Managed ServicesAustraliaSalesforce Verified

“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.”

Sales CloudSlackFlowAgentforceMuleSoft
ManufacturingAustraliaSalesforce Verified

“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.”

Sales CloudFinancial Services CloudArchitectureAI
Financial ServicesUnited StatesSalesforce Verified

“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.”

SalesforceExperience CloudCustom DevelopmentAutomationReporting
Salesforce ImplementationSalesforce Verified

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.

What do you need built, or read?

Pick the closest fit to what you are trying to ship. You can add detail next.

Which clouds or systems are in scope?

Optional. Choose any that apply, or skip ahead.

Where does your org stand today?

Optional. A few sentences is plenty: what is working, what is stuck, and what you want to be true. Or skip ahead and tell us on the call.

Who should the architect reach?

A certified architect will reply to these details.

Takes about 30–60 seconds · No obligation · Architect replies within one business day

Protected by reCAPTCHA. Google's Privacy Policy and Terms apply.

Book reviewCallWhatsApp

Solutions, built
for the future

Sales CloudSales Cloud
Service CloudService Cloud
Field ServiceField Service
Experience CloudExperience Cloud
Marketing Cloud NextMarketing Cloud Next
Revenue Cloud AdvancedRevenue Cloud Advanced
Salesforce CPQSalesforce CPQ
Data 360Data 360
Financial Services CloudFinancial Services Cloud
Nonprofit CloudNonprofit Cloud
Health CloudHealth Cloud
CRM Analytics & EinsteinCRM Analytics & Einstein
AgentforceAgentforce