Performance in Salesforce extends beyond page load times. It encompasses system responsiveness, transaction throughput, and long-term stability under evolving workloads.
In practice, even minor inefficiencies such as overloaded Lightning components, excessive custom fields, or inefficient test orchestration can cascade into user frustration and delayed releases.
Drawing on years of engineering experience, Oktana applies continuous performance testing — large-scale load simulations, bulk API stress tests, and real-time monitoring — to identify bottlenecks before they reach production and to ensure Salesforce environments remain stable and scalable as complexity grows.
Identifying the Real Bottlenecks
Performance issues rarely come from one place. Oktana’s engineers study both bulk behavior and individual user experiences to pinpoint the source.
“Page load times are fairly slow… we’re using a very customized Lightning implementation.” — Salesforce engineer on r/salesforce
From our own projects, we’ve observed that performance challenges tend to break down like this:
Common Salesforce Performance Bottlenecks
- 40% Customizations and overloaded page layouts
- 25% Network, browser, and hardware constraints
- 20% Test enqueue delays
- 15% API governance limits
By mapping these bottlenecks across environments, Oktana builds a tailored strategy: sometimes it’s reducing fields and related lists, sometimes it’s smarter test orchestration, and sometimes it’s as basic as monitoring CPU use during heavy workloads.
Bulk Actions vs. Individual Optimizations
One of the recurring lessons from our work is knowing when to act in bulk — and when to fine-tune individually.
- Bulk:
Running large-scale API load simulations to understand how 1,000 simultaneous transactions affect response times.
Running test suites across environments nightly to identify regression trends. - Individual:
Profiling page load for one user journey (e.g., opening an Account record with 200 custom fields).
Isolating a single Apex test that’s stuck in the queue to uncover whether enqueue time is the culprit. - “The actual time it takes to run the test vs. the time it takes to enqueue a test to run — that’s what’s killing me.” — Salesforce developer on Reddit
Test Execution Time Breakdown
- Naïve unit test: 2–3 minutes
- Optimized with @testSetup: 45–60 seconds
- Optimized with DML mocking: < 30 seconds
(Insert bar chart here)
Oktana engineers consistently apply this philosophy: hit the system hard in bulk, but never lose sight of the single user’s click.
Continuous Monitoring for Long-Term Gains
Salesforce isn’t static — releases, customizations, and user growth all impact performance over time. That’s why Oktana integrates continuous monitoring into every engagement.
- “You couldn’t realistically inject a heavy enough load with only UI… so load with API and run a few UI tests at the same time.” — Community advice on Salesforce performance testing
Our continuous approach includes:
- API-first monitoring: JMeter or K6-based load tests for core transactions.
- UI thin-layer testing: a handful of simulated users validating the front-end under API stress.
- Trend analysis: tracking Octane scores, response times, and enqueue delays over weeks and months.
Org Maturity in Performance Testing
- 60% Ad hoc testing
- 25% Some automation
- 10% Continuous integration testing
- 5% Mature continuous performance testing
Oktana’s Performance Testing Philosophy
- Diagnose first: Identify whether the slowdown is customization, infrastructure, or testing overhead.
- Act in layers: Bulk tests at the API level, fine-tune individual UX issues.
- Continuously monitor: Treat performance like security — always running, always adapting.
When applied consistently, this approach transforms Salesforce orgs from unpredictable environments into reliable platforms that scale with the business.
How Oktana Automates Continuous Performance Testing
At Oktana, we don’t see performance testing as a one-off activity — it’s built into our delivery pipeline. Every deployment and every configuration change is validated against performance baselines that we’ve established over years of Salesforce projects.
- Automated orchestration: We run scheduled tests inside CI/CD pipelines, ensuring that no new deployment degrades load times or API responsiveness.
- Smart alerts and diagnostics: Our monitoring stack immediately flags performance regressions, and our engineers receive context-rich alerts with probable root causes.
- Scaling tests: We’ve designed frameworks that let us simulate 100 or 10,000 concurrent users with minimal overhead, so clients can see how their org behaves under real-world conditions.
- “When Salesforce releases something new, it can cause havoc on existing test setups. That’s why we built automation that adapts — it updates itself when the platform changes.” — Oktana QA Lead
Automation Outcomes We Deliver
- 35% faster regression detection
- 40% reduction in time spent diagnosing bottlenecks
- 25% lower test maintenance costs compared to ad hoc testing
7. How Oktana Builds a Culture of Performance
Technology alone doesn’t guarantee speed. At Oktana, we’ve learned that the biggest differentiator is mindset. We embed performance ownership into every role across a project:
- Developers: We enforce best practices such as bulkified Apex, reduced inline SOQL, and reusable @testSetup patterns to minimize execution time.
- Admins: We routinely audit Lightning pages, cut down redundant fields, and redesign slow layouts to ensure faster page rendering.
- QA Engineers: We benchmark test times across sprints and use advanced techniques like DML mocking to shrink test runtime.
- Project Leaders: We treat performance KPIs as seriously as functional KPIs, reviewing metrics during retrospectives and not just at go-live.
“We don’t wait for users to complain about speed. Performance is a feature, and we treat it like one.” — Oktana Architect
Where Responsibility Falls in Our Projects
- Developers – 40%
- Admins – 25%
- QA – 20%
- Leaders – 15%
