Software Performance Optimization

We ran Codeflash on Netflix's open-source infrastructure. ~100 performance optimizations were hiding in plain sight! Netflix Zuul handles billions of proxied requests. Eureka powers service discovery across thousands of microservices. These aren't toy projects. They're maintained by exceptional engineers and run at a scale most of us will never touch. We still found 99 performance optimizations. Here are some remarkable ones: - The 29x speedup on every single request (Zuul) HttpUtils.extractClientIpFromXForwardedFor: runs on every proxied request, millions of times per second at Netflix. - Original: String.split(","): spins up a regex engine, allocates an array, splits the whole string. - Optimized: indexOf(",") + substring(): find the first comma, take the prefix. Result: 561 µs → 18.5 µs. 29x faster. One line changed. The config tax nobody noticed (Eureka) 14 methods in DefaultEurekaServerConfig had the same bug: every call to a config getter getEvictionIntervalTimerInMs(), shouldBatchReplication(), getJsonCodecName(), was creating a brand-new DynamicProperty object. Every. Single. Call. Fix: a lazy volatile field. Create the object once, return it forever. Speedups: 4x to 7x. Why does this matter? None of these are bugs you'd catch in code review. You can't see allocations in a diff. You find them by profiling and by running thousands of microbenchmarks across every function in the codebase. And here's the scale math: Zuul processes millions of requests per second. A 29x speedup on a function that runs on every request isn't a curiosity, it's real infrastructure cost, at real scale, adding up every second. The engineers who built Zuul and Eureka are excellent. The issue isn't skill. It's that performance regressions accumulate silently, and the only way to catch them is systematic measurement. That's what CodeFlash does. Automatically, on every PR. We found 99 of these in two of Netflix's most critical open-source projects. What's hiding in yours? Link to Optimization PRs: https://lnkd.in/gW6eEXsY https://lnkd.in/gRGs6caw

🚨 Consider this scenario: It's 2 AM, and your monitoring tools alert to sustained high CPU utilization on a routine SQL Server query. The immediate team response? "Scale the VM vertically—add 4 vCPUs to the instance." This is a common pattern we've all encountered. In 99% of incidents, the default action is to provision additional compute resources: it's efficient to implement, perceived as low-risk, and defers a full root-cause analysis. Yet, the ongoing expense is rarely modeled upfront. That initial scaling incurs roughly $30,000 in additional annual cloud compute and licensing charges, escalating as underlying inefficiencies drive further provisions—potentially doubling to $60,000+ by year three, and accumulating over $150,000 across five years. This stems from favoring tactical capacity expansion over query optimization or indexing. If we applied total cost of ownership calculations from the outset, would that shift decisions toward sustainable fixes rather than iterative scaling? Based on client engagements, it consistently does. Now, let's evaluate three practical alternatives for resolving that CPU-bound performance issue: 🖥️ **OPTION 1 — Add 4 vCPUs (SQL Server Enterprise)**   * 5-yr cost w/ Software Assurance: $146,000+   * Performance gain: 10-50 ms faster/query   * Impact: Marginal — underlying query logic remains inefficient   * Risk perception: ✅ “Low disruption”  🗂️ **OPTION 2 — Add an Index**   * 5-yr cost: $0 (engineering time only)   * Performance gain: 200% faster   * Impact: 1 sec saved × 1M executions/day = 11.5 days saved per day   * Risk perception: ⚠️ “Schema modification—potential for unintended side effects?”  ⚡ **OPTION 3 — Optimize the Code**   * 5-yr cost: $0 (engineering time only)   * Performance gain: 100% faster   * Impact: 500 ms saved × 1M executions/day = 5.75 days saved per day   * Risk perception: 🚨 “Application changes—testing required to validate stability?”  The key insight: The option viewed as lowest risk often carries the highest long-term cost with limited returns, while no-cost optimizations deliver outsized value.  💡 **The essential change:** Integrate FinOps metrics directly into capacity planning discussions. When data reveals a $146K vCPU expansion yields just 1% of an index's efficiency gains, priorities realign. For every incident, evaluate:   * 📈 What’s the 5-year TCO across options?   * ⚡ What’s the throughput improvement per dollar invested?   * 🤔 Are we mitigating perceived risks or aligning with operational KPIs?  Engineers, leverage these analyses to advocate for code-level resolutions over hardware scaling. Leaders, this approach curbs unchecked infrastructure spend and preserves margins. Move beyond siloed decisions—balance cost, capacity, and reliability systematically.  Check out WISdom at FORTIFIED to help bring FinOps into the conversation. #FinOps #DatabaseOptimization #TotalCostOfOwnership #SQLServer #EngineeringLeadership #PerformanceOptimization

We care a lot about user experience at Duolingo and monitor it via a number of app performance metrics. App performance is especially a challenge on Android because of the breadth of the ecosystem of devices. In 2021, we ran a cross-company Android reboot effort to improve the code architecture and improve latency. We then set latency and performance guardrails to prevent new changes from slowing down the app. Despite our best efforts, though, latency crept up. Early in 2024, one of our data scientists, Daniel Distler, was able to demonstrate that improving latency in some key parts of the user journey would drive solid increases in DAUs (daily active users), one of our main company metrics. This was the nudge we needed to re-invest in the effort. We created a cross-company tiger team to work on improving Android performance. Throughout the year, 20 software engineers participated. In 2024, the team ran 200+ A/B tests on Android performance and delivered remarkable results: - Entry-level device app open conversion jumped from 91% to 94.7% - Entry-level device users experiencing 5+ second app open latency dropped from 39% to just 8% - Hundreds of thousands of DAU gains were directly attributable to these performance enhancements and we expect the actual long-term impact was even larger What work proved most impactful? - Almost half of our DAU impact came from improving code efficiency - Another 20% of impact came from optimizing network requests  - Another chunk came from deferring non-critical work to happen later in key flows - Baseline profiles took a lot of time to get right, but sped up application start-up by 30% Want to learn more? Check out Chenglai Huang and Michael Huang’s blog post: https://lnkd.in/dni58Hez #engineering

Our App Was Crawling at Snail Speed… Until I Made This One Mistake 🚀 A few months ago, I checked our Lighthouse scores—30s. That’s like running an F1 race on a bicycle. 🏎️➡️🚲 𝐀𝐧𝐝 𝐭𝐡𝐞 𝐰𝐨𝐫𝐬𝐭 𝐩𝐚𝐫𝐭? We did everything right—modern stack, top framework, best practices. Yet, our app was sluggish. ❌ AI-powered search engines ignored us. ❌ Users kept waiting. ❌ Something was off. So, we did what every dev does—optimize. 🔧 Cut dependencies 🔧 Shrunk bundles 🔧 Tweaked configs We went from 30s to 70s. Better, but still not great. Then, I made a 𝐦𝐢𝐬𝐭𝐚𝐤𝐞. A glorious, game-changing mistake. One deploy, I accidentally removed JavaScript. And guess what? Lighthouse: 91. 😳 Sure, nothing worked. No buttons, no interactivity. But it proved our app could be fast. 💡 The lesson? Stop making JavaScript do everything. 𝐒𝐨 𝐰𝐞 𝐫𝐞𝐛𝐮𝐢𝐥𝐭: ✅ JavaScript only where needed ✅ No unnecessary hydration ✅ No bloated client-side rendering 𝐓𝐡𝐞 𝐫𝐞𝐬𝐮𝐥𝐭? 🚀 From 30s to consistent 90+ scores 🚀 Faster load times 🚀 Better search engine visibility Sometimes, the problem isn’t a lack of optimization—it’s an excess of complexity. Not every app needs a heavy framework. Not every UI should be hydrated. If you’re struggling with performance, ask yourself: ❓ Do I really need this much JavaScript? ❓ Can I pre-render more? ❓ What happens if I strip everything back to basics? You might be surprised by what you find. 👀

Had an interesting session with a client this week who was facing serious SQL Server performance issues. Long-running queries, CPU spikes, and timeouts during peak hours. We started by reviewing their execution plans and found a couple of red flags—missing indexes and suboptimal join patterns. 🔧 What we did: Tuned two critical server-level configurations (one related to MAXDOP, the other to cost threshold for parallelism). Added two well-targeted nonclustered indexes to reduce key lookups and improve seek performance. Made three precise query changes—including replacing scalar UDFs with inline logic and optimizing WHERE clause filters. 🚀 The outcome? The same workload that took minutes now completes in seconds. CPU utilization dropped significantly, and users noticed the difference right away. No hardware upgrade. No magic—just smart tuning. Performance tuning isn’t about throwing everything at the wall. Sometimes, just five well-placed changes can turn a system around. #SQLServer #PerformanceTuning #QueryOptimization #IndexingMatters #DatabaseEngineering #RealWorldSQL

How to Spot Performance Bottlenecks in Your C++ Code Using Perf (Linux Edition) Last week, we ran a poll, and performance profiling was the top pick. I’m thrilled because understanding exactly where your program is spending time is one of the most valuable skills for any C++ developer — and yet, tools like perf are still underused by many working on high-performance systems. perf is a Linux profiling tool that lets you observe your program at runtime. It tracks CPU cycles, cache misses, branch mispredictions, and shows you which lines of code consume the most time. For complex systems and performance-critical applications, it’s a game changer. We recently ran a test on a C++ program that fills a large std::vector. Running it under perf clearly showed that line 31 — the push_back loop — was our main bottleneck. This function was responsible for repeated allocations and copying as the vector grew. Thanks to perf, we quickly realized that adding a reserve() before the loop would fix the problem. After making this change and profiling again, our application ran about 3x faster. Simple, targeted optimization guided by profiling. That’s the power of runtime performance analysis. This example perfectly illustrates why integrating perf in your workflow — including in Qt projects — can save hours of guessing, trial-and-error, and frustration. Instead of wondering why your app is slow, you see exactly where the time is being spent and know exactly how to fix it. Key takeaway: Use profiling tools like perf to identify bottlenecks, understand your CPU usage, and apply small, precise changes that multiply your performance. C++ MasterClass, Michel Tonetti, Fabio Galuppo, Gabriel Azevedo Miguel #CppPerformance #PerfLinux #Cpp23 #SystemsProgramming #CppCommunity #Optimization #LowLevelProgramming #CppDev #ProfilingTools #HighPerformanceCpp #EngineeringExcellence #PushBackBottleneck #VectorReserve #CppBestPractices

A few months ago, a user reached out to me with a simple complaint — “Our dashboard isn’t loading.” What looked like a small issue turned out to be a major performance bottleneck. The dashboard was powered by a data set that fetched every Account along with all its Contacts — thousands of records loaded at once. It worked perfectly in the sandbox with limited data, but in production, it was pulling hundreds of thousands of records each time the dashboard refreshed. The system wasn’t slow — our query design was. We optimized it by: 1️⃣ Using Filters: Retrieved only relevant records instead of everything. 2️⃣ Applying Lazy Loading: Fetched related data only when users actually needed it, not by default. 3️⃣ Creating Indexes: Added selective indexing on key fields to speed up retrieval. After optimization, the same dashboard that once took 40 seconds now loaded in less than 3. That day taught me a valuable lesson: “Performance issues rarely come from the platform — they come from how we design on it.” Since then, whenever I build or review a Flow, report, or Apex process, I remind myself: Don’t just make it work. Make it scale. #Salesforce #Performance #Optimization #TrailblazerCommunity #Apex #FlowBuilder #SalesforceDeveloper #BestPractices

Practical SAP RAP Tips for Building Efficient Fiori Apps As SAP continues to push clean core, cloud-first, and AI-assisted development, the RESTful ABAP Programming Model (RAP) has firmly established itself as the standard for building scalable and future-proof Fiori applications on S/4HANA and SAP BTP ABAP Environment. Based on recent project experiences and SAP’s latest enhancements (2025–2026), here are practical RAP best practices every ABAP and BTP developer should follow. 🧱 1. CDS Views: Model Smart, Not Heavy Your RAP application is only as good as its CDS foundation. Best practices: Layer CDS views correctly Use Interface views (I_) for reusable logic and Projection/Consumption views (P_/C_) to expose only what the UI or API needs. Avoid SELECT * Explicit field selection reduces data transfer and improves HANA push-down performance. Prefer associations over joins Associations enable lazy loading and are far more efficient for Fiori Elements navigation. Add UI annotations early Annotations like @UI.lineItem and @UI.selectionField drastically reduce custom UI5 code. 📌 Result: Faster performance and near-zero UI coding for Fiori Elements apps. ⚙️ 2. Behavior Definitions: Let RAP Do the Heavy Lifting RAP is designed to handle standard business behavior—don’t fight the framework. Key recommendations: Use managed scenarios by default CRUD, locking, drafts, and validations come for free. Enable strict mode (use strict;) Ensures upgrade safety and lifecycle stability. Declare side effects Let the UI refresh intelligently when dependent fields change. Use prechecks wisely Validate early to avoid unnecessary server roundtrips. Leverage AI assistance (Joule / ABAP AI) Generate validations, determinations, and even full RAP artifacts directly from prompts. 🤖 AI is no longer optional—it’s becoming part of the ABAP developer toolkit. ⚡ 3. Performance Optimization: Think HANA-First Performance issues in RAP usually come from doing too much in ABAP. Optimize by: Pushing calculations, filters, and aggregations into CDS Using ETags and timestamps for safe concurrency Ensuring proper indexing on underlying tables Profiling with SAT, ABAP Cross Trace, and SADL diagnostics Using OData paging ($top, $skip) and avoiding deep entities when unnecessary 📊 Good RAP apps scale naturally when CDS does the work. 🎨 4. Fiori Apps: Annotation-Driven, Not Code-Driven If you’re still building freestyle UI5 for standard CRUD apps, you’re slowing yourself down. Follow this approach: Use Fiori Elements first Rely on draft-enabled BOs for enterprise-ready UX Extend clean-core systems via side-by-side BTP extensions ✨ Annotations + metadata = enterprise UX with minimal effort. #SAP #ABAP #RAP #SAPBTP #S4HANA #Fiori #FioriElements #CleanCore #CloudABAP #SAPDevelopers #EnterpriseArchitecture #AIinSAP