Study guide
10.1 Application Lifecycle Management (ALM) Stages & Governance
Salesforce Certified Platform App Builder Exam
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Platform Architecture, Boundaries & Extensions
1.1 Declarative vs. Programmatic Architecture & Limits 1.2 AppExchange Solutions & Package Selection 1.3 Core CRM Standard Objects & Capabilities
2 Chapter 2: Security, Access & Analytics
2.1 Object-Level & Field-Level Security 2.2 Record-Level Sharing Architecture 2.3 Advanced Sharing & Scoping Solutions 2.4 Reports, Custom Report Types & Dynamic Dashboards
3 Chapter 3: Data Model Architecture & Relationships
3.1 Custom Objects & Custom Field Types 3.2 Master-Detail & Lookup Relationships 3.3 Many-to-Many Relationships & Junction Objects 3.4 Schema Builder & Data Architecture Visualization
4 Chapter 4: Data Management & External Integrations
4.1 Field Type Conversions & Data Loss Considerations 4.2 Data Import Wizard vs. Data Loader 4.3 Salesforce Connect, External Objects & Indirect Lookups
5 Chapter 5: Declarative Formulas & Validation Rules
5.1 Cross-Object Formulas & Advanced Formula Functions 5.2 Roll-Up Summary Fields & Calculation Rules 5.3 Validation Rules & Error Handling Strategies
6 Chapter 6: Salesforce Flow Architecture & Design
6.1 Flow Fundamentals & Flow Trigger Types 6.2 Record-Triggered Flows: Fast Field Updates vs. Actions 6.3 Screen Flows & Guided User Interactions 6.4 Flow Execution Architecture, Bulkification & Fault Paths
7 Chapter 7: Complex Automation & Approval Processes
7.1 Multi-Step Approval Processes & Approver Routing 7.2 Approval Actions, Rejections & Record Locking 7.3 Automation Selection Strategy & Legacy Migration Patterns
8 Chapter 8: Lightning App Builder & Page Customization
8.1 Lightning Record, Home & App Pages 8.2 Standard, Custom & AppExchange Lightning Components 8.3 Custom Buttons, Web Links & Quick Actions
9 Chapter 9: Dynamic UI, Record Types & Mobile Experience
9.1 Dynamic Forms & Conditional Component Visibility 9.2 Dynamic Actions & Page Interaction Patterns 9.3 Record Types, Business Processes & Picklist Control 9.4 Salesforce Mobile App Customization & Compact Layouts
10 Chapter 10: Application Lifecycle Management & Sandboxes
10.1 Application Lifecycle Management (ALM) Stages & Governance 10.2 Sandbox Types, Capacity & Refresh Cycles 10.3 Sandbox Strategy for Development, Testing & Training
11 Chapter 11: Deployment Tools & Packaging Strategies
11.1 Inbound & Outbound Change Sets 11.2 Change Set Dependency Tracking & Deployment Sequencing 11.3 Managed vs. Unmanaged Packages & Distribution
12 Current Exam Blueprint, Agentforce & Flow Operations
12.1 Current Exam Facts, Official Weights & Study Mapping 12.2 AgentExchange: Extending an Org with the Agentforce Marketplace 12.3 Agentforce Automation for App Builders 12.4 Flow Approval Processes, Monitoring & Troubleshooting
10.1 Application Lifecycle Management (ALM) Stages & Governance
Key Takeaways Explain This Topic AI
Salesforce ALM defines six structured stages: Plan, Develop, Test, Build Release, Test Release, and Release, ensuring controlled, predictable metadata promotion.
Developing directly in production violates enterprise change governance, risks immediate data corruption, triggers untested automations, and bypasses audit compliance such as SOX.
A Center of Excellence (CoE) defines strategic platform vision, enterprise architecture standards, and data governance, whereas a Change Advisory Board (CAB) manages operational release approvals and deployment schedules.
Release management categorizes changes into Major Releases (monthly or quarterly strategic milestones), Minor Releases (weekly or bi-weekly low-risk features), and Emergency Hotfixes (critical production bug repairs).
A strict ALM governance framework dictates that emergency hotfixes must be backported immediately to in-flight development sandboxes to prevent regression during subsequent release cycles.
Last updated: October 2026
10.1 Application Lifecycle Management (ALM) Stages & Governance
In an enterprise Salesforce environment, delivering business value requires far more than technical proficiency with Flow Builder, custom objects, or Lightning App Builder. It demands a rigorous, disciplined framework for designing, building, validating, and deploying metadata changes without disrupting active business operations. This disciplined methodology is known as Application Lifecycle Management (ALM) .
Without structured ALM processes, organizations inevitably descend into chaotic development patterns: modifying configuration directly in production, overwriting peer configurations, introducing regressions, triggering unintended customer-facing automated notifications, and failing regulatory compliance audits (such as Sarbanes-Oxley / SOX). For the Salesforce Certified Platform App Builder, understanding the formal stages of ALM, enterprise governance models, release train cadences, and environment management is essential for architecting reliable, scalable solutions.
The Anti-Pattern: Developing Directly in Production
One of the most dangerous misconceptions in cloud development is that declarative "point-and-click" changes are inherently safe to configure directly in a live production environment. In reality, modifying production metadata directly introduces critical organizational risks:
Unintended Automation Triggers : Activating a Record-Triggered Flow or validation rule in production can immediately lock thousands of database records, cause bulk integrations to fail, or send erroneous email alerts to active customers.
Configuration Overwrites & Race Conditions : When multiple administrators or developers make simultaneous changes in production without source tracking, they silently overwrite one another's work without reliable version history; Setup Audit Trail alone is not a source-control or release-review process.
Data Inconsistency and Corruption : Modifying picklist values, required field properties, or formula dependencies on live records can break reporting pipelines and corrupt data integrity across historical records.
Audit and Compliance Violations : Organizations may require segregation of duties, approvals, and audit records under their own change policies. Determine the controls applicable to the organization rather than treating every named law as one universal Salesforce deployment rule.
Important
The Golden Rule of ALM: Production is exclusively for live business execution, not development. All customization, configuration, and coding must originate in an isolated sandbox environment, pass through structured testing gates, and arrive in production through an authorized, audited deployment pipeline.
The Six Formal Stages of Salesforce ALM
Salesforce defines a standard six-stage lifecycle that governs the progression of changes from concept to live production availability: [1. Plan] ──► [2. Develop] ──► [3. Test] ──► [4. Build Release] ──► [5. Test Release] ──► [6. Release]
Stage 1: Plan
Every initiative begins with planning. During this stage, business stakeholders, product owners, enterprise architects, and app builders collaborate to translate business needs into detailed technical specifications:
Requirements Gathering & User Stories : Capturing user requirements with clear, testable acceptance criteria.
Architectural & Security Design : Determining whether requirements should be solved declaratively (Flow, Validation Rules) or programmatically (Apex, LWC), evaluating governor limits, and assessing data security implications.
Backlog Prioritization : Categorizing user stories into release cycles (major releases, minor enhancements, or quick wins).
Environment Planning : Identifying which sandbox tiers will be required for development, integration, and testing.
Stage 2: Develop
Development takes place in isolated development environments—typically Developer Sandboxes or modern Scratch Orgs :
Isolated Construction : Builders configure custom fields, create Record-Triggered Flows, design Lightning pages, or write Apex code without impacting any other team member's workspace.
Source Tracking & Version Control : Utilizing modern source control (such as Git) or change tracking to maintain an auditable record of every granular metadata modification.
Controlled Test Data : Developer environments usually use synthetic or approved masked data. Sandbox type, copying behavior, permissions, and post-copy safeguards must be reviewed; a sandbox is not an automatic privacy guarantee.
Stage 3: Test
Once development is completed within an isolated sandbox, the author conducts initial verification:
Unit Testing : Testing individual components in isolation against expected positive and negative input values.
Apex Unit Tests : Executing Apex test classes to verify that all programmatic code satisfies the mandatory platform requirement of at least 75% test code coverage (with 100% pass rates).
Boundary & Validation Testing : Verifying that edge-case scenarios, validation rules, and flow fault paths behave as designed.
Stage 4: Build Release
In this pivotal aggregation stage, individual features developed across disparate sandboxes are consolidated into a single cohesive release package:
Metadata Bundling : Collecting all modified custom fields, flows, layouts, permission sets, and classes into a single deployment artifact (such as an Inbound Change Set, a Salesforce DevOps Center work item, or a version-controlled deployment branch).
Dependency Resolution : Identifying and resolving missing metadata dependencies (e.g., ensuring a custom field referenced by a Flow is explicitly included in the deployment package).
Integration Sandbox Deployment : Promoting the release artifact into a shared integration environment (such as a Developer Pro or Partial Copy Sandbox) to resolve merge conflicts and verify that components authored by different builders function harmoniously.
Stage 5: Test Release
The integrated release package is subjected to comprehensive, real-world evaluation in an environment that closely replicates production (such as a Partial Copy Sandbox or Full Sandbox ):
User Acceptance Testing (UAT) : Business end-users execute realistic end-to-end operational workflows to verify that the release satisfies business acceptance criteria.
System Integration Testing (SIT) : Validating bi-directional data exchanges and API callouts with external enterprise systems (e.g., ERP, billing gateways, marketing automation platforms).
Performance & Load Testing : Executing bulk data operations to verify that batch jobs and automations do not breach governor limits under heavy transaction volumes.
Regression Testing : Verifying that new features have not inadvertently broken existing platform functionality or reporting dashboards.
Stage 6: Release
The final stage is the authorized deployment of the tested metadata package into the live Production organization:
Pre-Deployment Execution : Completing any manual prerequisite setup steps that cannot be deployed via metadata APIs (e.g., enabling platform feature toggles, configuring third-party connected app secrets).
Metadata Deployment : Executing the deployment via change sets or CI/CD pipelines, typically during a scheduled maintenance window with minimal active user traffic.
Post-Deployment Execution : Running post-deployment configuration tasks, such as activating flows, assigning permission sets, seeding production reference data, and verifying integration endpoints.
Hypercare & Training : Providing immediate real-time support for end-users, monitoring debug logs for unhandled exceptions, and conducting user enablement sessions.
Enterprise Governance Frameworks
As organizations expand their Salesforce footprint across multiple business units, robust governance frameworks become essential to manage competing priorities, maintain platform integrity, and enforce compliance.
Center of Excellence (CoE)
A Center of Excellence (CoE) is a cross-functional leadership body that defines the strategic direction, architectural standards, and operational guidelines for the Salesforce platform across the entire enterprise.
Composition : Executive sponsors, enterprise architects, IT leadership, business unit stakeholders, security officers, and lead Salesforce administrators.
Core Responsibilities :
Establishing enterprise architecture patterns (e.g., "Clicks-Before-Code" standards, naming conventions).
Managing the overarching enterprise roadmap and prioritizing large-scale capital investments.
Enforcing data governance, master data management (MDM), and compliance policies (GDPR, HIPAA).
Defining sandbox management strategies and DevOps tooling standards.
Change Advisory Board (CAB) / Change Control Board (CCB)
While the CoE focuses on long-term strategy, the Change Advisory Board (CAB) —also called the Change Control Board (CCB)—is an operational governance committee responsible for reviewing, scheduling, and approving day-to-day release candidates before they are deployed to production.
Composition : Release managers, lead architects, QA leads, business analysts, and system administrators.
Core Responsibilities :
Evaluating release risk: Assessing potential business disruption, downtime requirements, and technical complexity.
Reviewing deployment dependencies and pre/post-deployment checklists.
Verifying UAT sign-offs and regression testing results.
Formulating and approving contingency rollback plans in the event of deployment failure.
Authorizing deployment windows (e.g., off-peak weekend release slots).
Release Trains & Deployment Cadences
Enterprise Salesforce teams organize their deployments into predictable, rhythmic cycles known as Release Trains . Instead of releasing features whenever they happen to be completed, teams adhere to strict calendar schedules:
Release Category Typical Frequency Scope of Changes Testing & Governance Gates
Major Release Monthly or Quarterly Large-scale strategic features, complex data model changes, multi-system integrations, significant workflow redesigns Full UAT, complete regression testing, performance testing in Full Sandbox, formal CAB approval
Minor Release Weekly or Bi-weekly Non-breaking enhancements, new formula fields, minor Flow logic tweaks, report/dashboard updates, bug fixes Peer review, unit testing in Dev Pro/Partial Copy, streamlined CAB sign-off
Emergency Hotfix As needed (On-Demand) Urgent break-fix repairs for critical production defects (e.g., broken revenue-blocking validation rule or failed nightly batch job) Expedited testing in isolated sandbox, emergency CAB approval, immediate deployment, mandatory backporting
Note
Salesforce Platform Triannual Releases: Salesforce delivers three major platform upgrades per calendar year: Spring , Summer , and Winter . Organizations must account for these vendor upgrades within their internal release calendar, leveraging Sandbox Preview windows to regression test custom metadata against upcoming Salesforce platform versions before production orgs are automatically upgraded.
Comparison: ALM Stages, Environments & Deliverables
ALM Stage Primary Objective Standard Environment Tier Primary Actors Key Deliverables
1. Plan Requirements gathering & technical architecture None (Jira, Confluence, Backlog) Business Analysts, Architects, Product Owners User Stories, Architecture Diagrams, Acceptance Criteria
2. Develop Building configuration and custom code Developer Sandbox / Scratch Org App Builders, Developers Custom Fields, Flows, Apex Classes, Layouts
3. Test Unit testing & code coverage verification Developer Sandbox App Builders, Developers Passing Apex Test Classes (at least 75% where required), Unit Test Logs
4. Build Release Bundling metadata & resolving dependencies Developer Pro / Integration Sandbox Release Managers, Lead Builders Change Sets, Deployment Manifests, Release Artifacts
5. Test Release UAT, SIT, and performance verification Partial Copy Sandbox / Full Sandbox End-Users, QA Testers, Business Stakeholders UAT Sign-off Sheets, Integration Verification Reports
6. Release Production deployment & hypercare Production Organization Release Engineers, Administrators Live System Functionality, Release Notes, Post-Deployment Logs
Exam Traps and Architectural Best Practices
Trap: Conflating the CoE and CAB. The Center of Excellence sets enterprise-wide vision, architectural principles, and long-term strategy. The Change Advisory Board reviews specific technical release manifests, evaluates immediate operational risk, and approves deployment schedules.
Trap: Premature Testing in the ALM Lifecycle. Unit testing occurs in Stage 3 (Test) within isolated developer sandboxes. However, formal User Acceptance Testing (UAT) and end-to-end integration testing do not occur until Stage 5 (Test Release) within a consolidated Partial Copy or Full Sandbox that mirrors production data volume and integration endpoints.
Trap: The Forgotten Hotfix Backport. When an emergency hotfix is deployed to production to resolve a critical operational failure, administrators frequently forget to backport that exact fix into active, in-flight Developer sandboxes. When the next scheduled major release deploys from those sandboxes to production, it overwrites the hotfix with stale metadata, re-introducing the critical defect into production!
Tip
Pre-Deployment & Post-Deployment Checklists: Some target-org setup and verification steps are not carried by a change set, such as email-address verification or environment-specific feature configuration. Standard value sets and other metadata may be supported by developer tools even when absent from change sets; check the coverage for the chosen tool. Always maintain an explicit, written pre- and post-deployment checklist as part of the formal release package reviewed by the CAB.
Official Source Check
Checked October 19, 2026: Sandbox types and intended testing uses .