Salesforce System Architect

Custom logic runs inside a transaction with hard limits. You write classes and triggers that handle bulk data, follow the order of execution, and fail cleanly when a limit or exception is reached.

• Classes, interfaces and trigger design
• SOQL, SOSL and DML in bulk
• Order of execution and its surprises
• Governor limits and how to stay inside them
• Exceptions and transaction control
• Asynchronous Apex: queueable and batch

You build A trigger framework that handles bulk loads and fails safely.

The interface and the process need to share the same logic. You build components that call Apex and sit beside flows, and decide which tool fits each interaction.

• Component structure, properties and events
• Reading data with wire and Apex
• Using components in flow screens and pages
• Securing components against data access flaws
• Flow types and when each fits
• Choosing between flow, component and code

You build A component and a flow that share one piece of business logic.

Code that is not tested is a liability on a shared platform. You write meaningful Apex tests, debug with logs and monitoring, and use Salesforce DX and the CLI to work in a repeatable way.

• Writing tests that assert behavior
• Test data and isolation
• Debug logs and monitoring asynchronous jobs
• Salesforce CLI commands for daily work
• Code coverage as a floor, not a goal
• Jest tests for components

You build A tested code module with a repeatable local workflow.

Change reaches production safely only through a deliberate process. You assess how mature a team’s lifecycle is, set up governance that fits, and design a sandbox strategy for several streams of work.

• Assessing application lifecycle maturity
• Governance bodies and decision rights
• Development methods against project risk
• Sandbox types and refresh strategy
• Planning for each Salesforce release
• Handling emergency changes

You build A governance model and sandbox map for a team with three work streams.

Source control makes change repeatable. You work with branches and merges, org-based and package-based development, scratch orgs and the tools that move metadata, with tests that gate each release.

• Branching, merging and versioning
• Org-based and package-based development
• Scratch orgs and source-driven work
• What the Metadata API and change sets can deploy
• Package types and versions
• Pipelines with automated tests
• Release and rollback planning

You build A deployment pipeline from branch to production with gated tests.

Single sign-on works by one system trusting another. You build that trust with SAML and OpenID Connect, act as service provider or identity provider as needed, and diagnose where sign-in fails.

• Authentication patterns and trust between systems
• SAML flows, assertions and certificates
• OpenID Connect and social sign-in
• Salesforce as a service provider
• Salesforce as an identity provider
• Troubleshooting failed single sign-on

You build A working single sign-on setup with a written troubleshooting guide.

Apps and APIs reach Salesforce through OAuth. You pick the flow that suits each client, set scopes and connected app policies, and manage tokens through expiry and revocation.

• Choosing a flow for a web app, a server and a device
• Authorization code and JWT bearer flows in practice
• Scopes and what they permit
• Connected app policies and IP rules
• Refresh tokens, expiry and revocation
• Securing client secrets and certificates

You build Connected apps for three client types, each with the right flow and scopes.

Identity does not end at sign-in. You select multi-factor methods, keep users and permissions in step with the identity provider, and audit logins so access stays right over time.

• Multi-factor methods and when each fits
• Just-in-time and SCIM provisioning
• Keeping permission sets in step with roles
• Session and login policies
• Login history and event monitoring
• Offboarding and deprovisioning

You build An access management plan with MFA, provisioning and audit steps.

Every connection needs a pattern and an interface. You compare request-reply, fire-and-forget, batch and event-driven approaches, and choose among the REST, SOAP, Bulk and event APIs with their limits in mind.

• Mapping systems and the data that flows between them
• Synchronous and asynchronous patterns
• Event-driven integration with platform events
• REST, SOAP, Bulk and Pub/Sub APIs
• Outbound callouts and named credentials
• Matching pattern, API and limits to a requirement

You build An integration design that pairs each requirement with a pattern and an API.

Integrations fail at the edges. You design error handling, retries and monitoring, secure the credentials each side holds, and plan how connections survive upgrades and outages.

• Error handling and dead-letter paths
• Idempotency and safe retries
• Securing credentials and endpoints
• Rate limits and backpressure
• Monitoring and alerting on integrations
• Surviving upgrades on either side

You build A resilience plan for one integration, covering errors, retries and alerts.

Design a system that needs custom code, a release process, single sign-on and external connections at once. You build the pieces, wire them together, and explain how each discipline protects the others.

• Scoping a system that spans four disciplines
• Building the logic and interface
• Releasing it through a governed pipeline
• Securing identity and the integration
• Reviewing the design for its weakest link

You build A working system with code, a pipeline, single sign-on and an integration, documented.