“People need to understand object-oriented programming, dependency injection, and all that, so that eventually the act of mocking the Salesforce database or mocking the dependencies becomes a lot more mainstream where most teams can achieve some level of very fast test execution. That’s why I took on the mission to bring the knowledge that exists outside the Salesforce ecosystem and bring it to the masses.” – Pablo Gonzalez, Director of Product Management and Research, AutoRABIT and author of Clean Apex Code: Software Design for Salesforce Developers.
The latest episode of “From Code to the Cloud” takes on a core—but often overlooked—truth about Salesforce development: You can’t practice DevOps without clean Apex code.
Andrew Davis, author of Mastering Salesforce DevOps and Flow Engineering, is joined by Pablo Gonzalez, Director of Product Management and Research at AutoRABIT and author of the new book, Clean Apex Code: Software Design for Salesforce Developers. Together, they explore why so many Salesforce teams struggle to fully embrace DevOps—and how the answer lies not in better tools, but in better thinking.
Here are four essential takeaways from the episode:
1. Slow Tests = Broken DevOps
The theory of Continuous Integration is simple: Developers commit code often, tests run fast, and the team moves quickly. But in practice, many Salesforce teams hit a wall: test runs that take more than 40 minutes. That’s not just an inconvenience; it’s a DevOps deal-breaker.
If you can’t run your tests in less than five minutes, you’re not doing Continuous Integration. And without that, you’re definitely not doing Continuous Delivery.
The solution? Mock the Salesforce database to radically reduce test time. But there’s a catch: Mocking well requires strong object-oriented design and an understanding of patterns like dependency injection—skills still uncommon in the Salesforce developer ecosystem.
2. Salesforce Supports Object-Oriented Programming—But the Ecosystem Doesn’t
Apex is object-oriented. It has classes, methods, and interfaces. But the tools are only half the story. The real problem is a knowledge gap.
Unlike Java or Python, Apex developers don’t have the same depth of community resources, mature libraries, or foundational training. Many learn through Trailhead alone. That makes it difficult to grasp advanced design concepts required for modern development: modularity, abstraction, boundaries.
Clean Apex Code was written to fill that void. Not with another framework, but with a clear mental model for making sound architectural decisions—ones that support fast feedback, clean boundaries, and scalable teams.
3. A Framework for Thinking, Not Just Organizing
If you’ve worked with the Apex Enterprise Patterns (FFLib), you know the drill: put this in a domain class, that in a service class, and selectors for SOQL. It’s structured, but rigid. Pablo’s new Apex Well-Architected Framework (AWAF) challenges that model.
Rather than prescribing where to put code, AWAF teaches you how to decide. What’s the purpose of separation? How do you identify when cohesion is too low or coupling is too high? How do you make trade-offs explicit?
In other words, it’s not about enforcing sameness—it’s about enabling clarity.
4. Modularity Isn’t Just Packaging—It’s Visibility
Too many Salesforce projects are a patchwork of unrelated metadata. Apex classes live one place, fields another, Lightning components somewhere else. Developers rely on naming conventions—or tribal knowledge—to figure out what fits where.
Pablo reframes this problem using the principles of coupling and cohesion.
Coupling isn’t always bad—it’s necessary. But it needs to be visible.
Cohesion is the antidote to scattered logic. Group related elements (Apex, fields, UI) into the same SFDX folder, so their interdependence is obvious.
It’s a mindset shift: use folder structure not just for organization, but as a tool for architectural clarity. If pieces change together, they should live together.
The Bottom Line
DevOps isn’t just pipelines and tools—it’s architecture, habits, and mental models. Without clean code, fast tests, and modular thinking, Salesforce teams will always be stuck in half-measures.
Pablo Gonzalez’s Clean Apex Code is more than a book—it’s a wake-up call. And this episode of “From Code to the Cloud” is essential listening for any Salesforce leader ready to build a future where fast feedback, smart structure, and secure releases are the norm, not the exception.
Next Step…
Listen to the episode now on your favorite podcast platform or stream it directly here.
Grab your copy of Clean Apex Code—and give your team the principles they need to scale well and ship with confidence.