CommunityDevOps ExchangePartners
10 minutes

Salesforce Best Practices for Small Batch Integration and Deployment

Written by
Halie Vining
Table of contents

DevOps was born out of lean operations in manufacturing. Just like manufacturers benefit from assembly lines—specialists efficiently completing a piece of work and passing it along to the next specialist—software development benefits from small batch sizes. When a developer completes a user story and hands it off to QA, they allow the development lifecycle to operate in parallel, creating a constant flow of work rather than a build and wait model.

Moreover, small batches enable a wealth of benefits beyond continuous workflow: low-risk releases, quicker time to feedback, features delivered sooner, etc.
Despite these benefits and the widespread adoption of CI/CD and version control, many companies still struggle to truly achieve agile processes. Why is this? One big reason is that companies are still deploying big batches, preventing teams from getting the full value out of DevOps.

In this article, we’ll take a look at the business benefits of small batches and discuss how you can enable lean methods in your Salesforce development processes.

The Cost of Large Batch Deployment

A batch refers to work (or grouping of work) that is deployed upstream to a new environment and/or to the next step of the development process. The efficiency of batch deployment has a significant impact on both productivity and innovation. Large batch sizes tend to increase the complexity of testing and release, elongating the time to value

The delay in value generation is tied to two primary costs in the development process: transaction costs and holding costs.

  • Transaction cost is the cost of deploying your software into production. It includes the labor required to move the developed feature through the system, integration, and user acceptance testing. 
  • Holding cost is the cost of the feature deployment delay to your organization. Until the end-user has access to the new feature and can use it, the feature cannot generate value or build ROI. In addition to the lag in ROI, holding also requires maintenance and tracking, adding more costs to your project.

If you expand the time between releases, your team develops more features, which are then placed in the queue for testing and deployment. Every incremental feature increases the complexity of the release. Essentially, the larger the batch the longer it takes to test and release, increasing time spent packaging deployments and project managing. Increasing both the cost to build (transaction cost) and delaying it the time to business value (holding cost).

Transaction costs aren’t recoverable, so the more you increase them, the lower your long-term ROI. So when large batches increase both transaction and holding costs, they can have a big impact on the ultimate ROI of the features you deliver.

The Benefits of Deploying Small Batches

While transaction costs are not recoverable from ROI, you can reduce them with small batches. If you need less resources to manage a feature release, you both accelerate it’s time to value and decrease transaction costs. Small batches also help reduce the variability, risk, and overhead. Let’s look at how shifting to small batches impacts your entire software delivery lifecycle to unlock those savings. 

Increase the Future Value Payment Schedule

The future value payment schedule refers to the time it takes for a feature to build ROI after deployment. When you deploy small batches more frequently, the feature goes into use and begins to generate value earlier than if all the features were kept until development was complete and deployed simultaneously. 

Your future value payment schedule grows because you reduce the additional project costs from tracking and queuing features that are ready for deployment. Instead, you begin to build ROI quickly for the entire project by starting to incrementally generate ROI from each feature deployed.

Deploy a feature, and it begins building ROI. Each feature after that adds more. If you wait until all components are ready to deploy, you lose any revenue that could have been generated during production. 

Reduce Lead Time and Increase Deployment Frequency

The shorter cycle times and shorter lead times allowed by smaller code changes mean features make it into production faster. You reduce variability in process flow with the predictability of small batch sizes.

Like the assembly line we mentioned earlier, small-batch production enables several specialists to work simultaneously. One specialist builds a small batch of work, sends it to the next specialist for testing, and so on. Each specialist takes care of a specific step in the process, so when you deploy small batches, you keep specialists working in parallel rather than in one long line (waterfall).

Reduce Variability in Your Delivery Flow

Large batches lead to testing and deployment queues, which causes release times to vary. With small batches, both the queue and the bottlenecks shrink. And when variability is reduced, you can plan and improve your delivery processes better, allowing you to build trust with the business.

Get Better Feedback Faster

Without feedback, you may make incorrect assumptions that change hundreds of future decisions. Rework due to delayed feedback is expensive and avoidable. With faster feedback, you may even discontinue a project before it becomes "too big to fail."

Faster feedback is possible with small-batch work because each feature is released upon completion and placed into production. The earlier it goes into production, the faster the customer can use the new feature and let you know what may need changing.

Also, with smaller deployments, the customer can concentrate on providing feedback for a single change as opposed to multiple changes.

Reduce Risk

A small batch with a short cycle time exposes your project to a lower risk of technology or requirement changes. If you have a large, complex feature to release, break it into smaller batches. This will allow your QA team to more effectively test dependencies and allow you to gather feedback on functionality more quickly. By reducing errors released and gathering feedback fast, you’ll increase the adoption—helping further increase ROI.

Reduce Overhead

The larger the batch, the higher the complexity—and higher risk for manual merge and testing errors. When you reduce manual work through continuous delivery, you also reduce human error. Your team spends less time deploying, less time doing rework, and more tine building profit-driving capabilities.

Enabling Small Batches for Salesforce Development

For some, DevOps has become synonymous with technologies like version control systems (git) and continuous integration systems (Jenkins), but true DevOps success is rooted in both process and technology. Just like manufacturing companies shifted their operations to assembly lines, software developers must also shift how they operate in order to get the most out of DevOps—and small batches.

The importance of admin-friendly version control

Version control has been core to software development for decades, with most companies leveraging Git repositories. Version control provides a history of changes that contains information essential for debugging and decision making, making both deployment prep and rollbacks more efficient.

Code repositories were built to be used by developers with scripting and command line as key functions used for merging. But if you’re building on a low-code platform like Salesforce, you’ve likely got a team of skilled Admins configuring updates. Salesforce Admins help push out new functionality rapidly, but as your org becomes more complex, managing config and code can be tricky.

That’s where a native platform like Copado comes in. Admins can click to commit. This allows Admins to quickly adopt DevOps processes without needing to learn how to code. And when your Admins can quickly commit, you’re one step closer to small, continually released batches. 

Integrate early & often

Next, you’ll need continuous integration, which enables teams to work in parallel. This allows your team to work more efficiently. Small batches are essential to getting the most out of CI systems and DevOps. And this is where process and technology start to overlap. 

First, you’ll need to adjust when you merge changes and deploy between sandboxes. It’s best practice to commit each piece of work once it’s completed and ready for testing. Automated unit testing allows developers and Admins to quickly and confidently commit. Teams may need to adjust their processes to support this model. Remember, DevOps is rooted in learning, and your teams will become more confident with frequent merges overtime, eventually making small batches.

Secondly, we’ll address the technology challenges of CI for Salesforce. Because Salesforce uses XML, developers cannot simply merge changes into a git repository. The XML must be packaged, which can be manual, time consuming, and error-prone. Copado automates packaging and can test for errors prior to merging. This is essential for leveraging small batches on Salesforce. Without automation, most teams will abandon small batches because it’s just too time consuming to deploy early and often.

Ready to get started with small batches?

DevOps success is rooted in process. Author of Mastering Salesforce DevOps, Andrew Davis walks teams through the power (and process) of source-driven development in our recent webinar series. Watch the session on demand here.





Book a demo

About The Author

Sr Director, Integrated Marketing Communications and Field Marketing

Halie is digital product and marketing strategist, with experience launching products and digital campaigns for B2B brands like Rackspace, Salesforce, Intel and HP. Her passion sits at the intersection of data and storytelling—and she's never met a pattern she didn't want to decipher.

Building a Scalable Governance Framework for Sustainable Value
Copado Launches Copado Explorer to Simplify and Streamline Testing on Salesforce
Exploring Top Cloud Automation Testing Tools
Master Salesforce DevOps with Copado Robotic Testing
Exploratory Testing vs. Automated Testing: Finding the Right Balance
A Guide to Salesforce Source Control
A Guide to DevOps Branching Strategies
Family Time vs. Mobile App Release Days: Can Test Automation Help Us Have Both?
How to Resolve Salesforce Merge Conflicts: A Guide
Copado Expands Beta Access to CopadoGPT for All Customers, Revolutionizing SaaS DevOps with AI
Is Mobile Test Automation Unnecessarily Hard? A Guide to Simplify Mobile Test Automation
From Silos to Streamlined Development: Tarun’s Tale of DevOps Success
Simplified Scaling: 10 Ways to Grow Your Salesforce Development Practice
What is Salesforce Incident Management?
What Is Automated Salesforce Testing? Choosing the Right Automation Tool for Salesforce
Copado Appoints Seasoned Sales Executive Bob Grewal to Chief Revenue Officer
Business Benefits of DevOps: A Guide
Copado Brings Generative AI to Its DevOps Platform to Improve Software Development for Enterprise SaaS
Celebrating 10 Years of Copado: A Decade of DevOps Evolution and Growth
Copado Celebrates 10 Years of DevOps for Enterprise SaaS Solutions
5 Reasons Why Copado = Less Divorces for Developers
What is DevOps? Build a Successful DevOps Ecosystem with Copado’s Best Practices
Scaling App Development While Meeting Security Standards
5 Data Deploy Features You Don’t Want to Miss
Top 5 Reasons I Choose Copado for Salesforce Development
How to Elevate Customer Experiences with Automated Testing
Getting Started With Value Stream Maps
Copado and nCino Partner to Provide Proven DevOps Tools for Financial Institutions
Unlocking Success with Copado: Mission-Critical Tools for Developers
How Automated Testing Enables DevOps Efficiency
How to Keep Salesforce Sandboxes in Sync
How to Switch from Manual to Automated Testing with Robotic Testing
Best Practices to Prevent Merge Conflicts with Copado 1 Platform
Software Bugs: The Three Causes of Programming Errors
How Does Copado Solve Release Readiness Roadblocks?
Why I Choose Copado Robotic Testing for my Test Automation
How to schedule a Function and Job Template in DevOps: A Step-by-Step Guide
Delivering Quality nCino Experiences with Automated Deployments and Testing
Best Practices Matter for Accelerated Salesforce Release Management
Maximize Your Code Quality, Security and performance with Copado Salesforce Code Analyzer
Upgrade Your Test Automation Game: The Benefits of Switching from Selenium to a More Advanced Platform
Three Takeaways From Copa Community Day
Cloud Native Applications: 5 Characteristics to Look for in the Right Tools
Using Salesforce nCino Architecture for Best Testing Results
How To Develop A Salesforce Testing Strategy For Your Enterprise
What Is Multi Cloud: Key Use Cases and Benefits for Enterprise Settings
5 Steps to Building a Salesforce Center of Excellence for Government Agencies
Salesforce UI testing: Benefits to Staying on Top of Updates
Benefits of UI Test Automation and Why You Should Care
Types of Salesforce Testing and When To Use Them
Copado + DataColada: Enabling CI/CD for Developers Across APAC
What is Salesforce API Testing and It Why Should Be Automated
Machine Learning Models: Adapting Data Patterns With Copado For AI Test Automation
Automated Testing Benefits: The Case For As Little Manual Testing As Possible
Beyond Selenium: Low Code Testing To Maximize Speed and Quality
UI Testing Best Practices: From Implementation to Automation
How Agile Test Automation Helps You Develop Better and Faster
Salesforce Test Cases: Knowing When to Test
DevOps Quality Assurance: Major Pitfalls and Challenges
11 Characteristics of Advanced Persistent Threats (APTs) That Set Them Apart
7 Key Compliance Regulations Relating to Data Storage
7 Ways Digital Transformation Consulting Revolutionizes Your Business
6 Top Cloud Security Trends
API Management Best Practices
Applying a Zero Trust Infrastructure in Kubernetes
Building a Data Pipeline Architecture Based on Best Practices Brings the Biggest Rewards
CI/CD Methodology vs. CI/CD Mentality: How to Meet Your Workflow Goals
DevOps to DevSecOps: How to Build Security into the Development Lifecycle
DevSecOps vs Agile: It’s Not Either/Or
How to Create a Digital Transformation Roadmap to Success
Infrastructure As Code: Overcome the Barriers to Effective Network Automation
Leveraging Compliance Automation Tools to Mitigate Risk
Moving Forward with These CI/CD Best Practices
Top 3 Data Compliance Challenges of Tomorrow and the Solutions You Need Today
Top 6 Cloud Security Management Policies and Procedures to Protect Your Business
What are the Benefits of Principle of Least Privilege (POLP) for My Organization?
You Can’t Measure What You Can’t See: Getting to know the 4 Metrics of Software Delivery Performance
How the Public Sector Can Continue to Accelerate Modernization
Building an Automated Test Framework to Streamline Deployments
How To Implement a Compliance Testing Methodology To Exceed Your Objectives
Cloud Security: Advantages and Disadvantages to Accessibility
Copado Collaborates with IBM to Accelerate Digital Transformation Projects on the Salesforce Platform
Continuous Quality: The missing link to DevOps maturity