Salesforce Development Lifecycle & Deployment Architect Exam Guide
Design safe, scalable and repeatable release processes on the Salesforce Platform. This guide covers the exam format, domains, study plan and scenario-style examples for the Salesforce Certified Development Lifecycle & Deployment Architect credential.
Who is the Dev Lifecycle & Deployment Architect for?
This certification is for professionals who lead or heavily influence DevOps, ALM and release strategy for Salesforce. You’re a good fit if you:
- Design the environment strategy (sandboxes, scratch orgs, packaging, branch strategy).
- Define release processes, governance and quality gates across multiple teams.
- Implement or guide CI/CD pipelines and source-driven development.
- Work with architects, developers, admins and program leaders to manage large Salesforce programs.
This is one of the key Domain Architect exams that contributes towards the Application Architect and System Architect composite credentials.
Exam Overview
📊 Exam at a Glance
| Exam Name | Salesforce Certified Development Lifecycle & Deployment Architect |
| Format | Proctored, multiple-choice / multiple-select, heavily scenario-based |
| Duration | 105 minutes |
| Number of Questions | ~60 scored questions (+ a few unscored items) |
| Passing Score | Typically mid-60% range (confirm the exact value in the latest exam guide) |
| Registration Fee | $400 USD (Retake: $200 USD) |
| Prerequisites | No mandatory certification prereq, but experience with DevOps tools, releases and multi-team programs is highly recommended. |
🧭 What this Exam Focuses On
Expect questions where you must design:
- End-to-end ALM processes from idea to deployment and support.
- Environment topologies using sandboxes, scratch orgs and packaging.
- Source control & CI/CD pipelines for admins and developers.
- Governance models including CoE, change control and release boards.
- Testing strategy, quality gates and risk-based deployment decisions.
Dev Lifecycle & Deployment Exam Domains
Domain names and percentages can shift slightly across releases, but the core areas remain stable. Use this breakdown as a practical map and always cross-check with the current official exam outline.
🔍 View High-Level Domains & Concepts
- Environment Strategy & Architecture – Sandboxes, scratch orgs, packaging, multi-org, branch strategy and alignment with non-Salesforce systems.
- Source Control & CI/CD – Git branching models, automated builds, deployments, quality gates and artifact management.
- Release Management & Governance – Change management processes, CoE, CAB, risk assessment and rollback planning.
- Testing & Quality – Test strategy, automation, code coverage, static analysis and regression protections.
- Operations & Monitoring – Incident response, on-call, deployment monitoring and continuous improvement loops.
The official exam guide should be your source of truth for exact domain weightage. Treat this list as the way you’ll actually think about and design solutions on projects.
- Stronger alignment with source-driven development and modern CI/CD tooling.
- More focus on packaging, modular architectures and multi-team programs.
- Questions involving governance models for large enterprises and multi-org strategies.
- Scenarios mixing Salesforce releases with other cloud platforms and integration touchpoints.
Key Design Areas for the Exam
🏗️ Environment & Branch Strategy
- Define how many sandboxes and scratch orgs are needed for each pipeline.
- Separate development, integration, UAT, training and production environments clearly.
- Align Git branching strategy (e.g. main/develop/release branches) with environment usage.
- Decide where to use unlocked/managed packages vs metadata deployments.
⚙️ CI/CD & Automation
- Design pipelines that include build, test, quality checks and deploy stages.
- Automate code analysis, unit tests, static code checks and metadata validation.
- Support both developer and admin changes (declarative, metadata and data).
- Implement rollback strategies and blue/green or phased releases where feasible.
🏛️ Governance & Release Management
- Set up a Center of Excellence (CoE) and change advisory boards (CAB) where needed.
- Define intake, prioritization and approval for changes and projects.
- Differentiate between standard changes vs high-risk changes needing more review.
- Ensure auditability of who approved, built, tested and deployed each change.
🧪 Testing & Quality Gates
- Design a layered test strategy: unit, integration, UAT, regression and performance testing.
- Use automated tests and quality checks as gates in the pipeline.
- Balance Salesforce minimum code coverage with realistic quality standards.
- Define go/no-go criteria for releases based on defects, coverage and risk.
📉 Operations, Incidents & Continuous Improvement
- Plan for incident management, on-call, and clear escalation paths.
- Monitor deployments, performance and key business KPIs during and after releases.
- Use post-incident reviews and release retrospectives to improve the pipeline.
- Continuously evolve standards, templates and automations as the program grows.
4-Week Study Plan (Adjust Based on Experience)
This sample plan assumes ~1–2 hours per weekday plus additional time on weekends. Extend or compress based on your background in DevOps and Salesforce programs.
Week 1 – ALM Fundamentals & Current State Assessment
- Read the official Development Lifecycle & Deployment Architect exam guide.
- Document how changes currently move from idea → build → test → deploy in your org.
- Review Salesforce docs on environments, sandboxes and scratch orgs.
- Identify gaps such as missing environments, lack of version control, or manual deployments.
Week 2 – Environment Strategy & Source Control
- Design a target environment strategy for a hypothetical or real program.
- Review Git basics, branching models and how metadata is stored in source control.
- Experiment with a simple repo: retrieve metadata, commit changes and simulate branches.
- Map how admins’ declarative changes will reach source control (e.g., via metadata retrieval tools).
Week 3 – CI/CD, Governance & Testing
- Study reference architectures for CI/CD pipelines in Salesforce.
- Design a pipeline that includes build, test, quality checks and deployment steps.
- Define a governance model: who approves changes, how CAB works, what is standard vs high-risk.
- Outline a test strategy across different environments and release types.
Week 4 – Scenario Practice & Mock Exams
- Practice reading long scenario questions and eliminating options based on risk and best practice.
- Take at least one or two full-length mock exams under timed conditions.
- Review weak domains and revisit docs or trailmixes focused on those areas.
- Prepare a 1–2 page summary of your recommended ALM approach – a useful asset for real projects too.
Sample Scenario-Style Questions
Question 1
A global Salesforce program has multiple scrum teams working on the same org. Each team currently deploys changes directly from Developer sandboxes to Production using change sets. Releases frequently overwrite each other and cause regressions. What should the architect recommend first?
Question 2
A regulated customer requires strict traceability of who approved and deployed each change. They also want to ensure that all deployments meet minimum testing and static code analysis standards. Which design best meets these requirements?
Question 3
A program is planning to introduce unlocked packages to modularize their large Salesforce implementation. What is the primary benefit from a deployment and lifecycle perspective?