3 Key Considerations for Mastering Software Performance
Practical Insights to Boost Your Software's Speed Without Overloading Effort
Performance, in software, is a bit like security. It’s one of those big words that we like to say we care about. In reality, unless you’re part of a niche of “performance -or security- experts”, you’d rather spend your time building and, hopefully, shipping.
I should say that there’s nothing wrong, in my view, with a desire to spend most of our time building and shipping.
But a good architect will always ensure that time is intentionally set aside to think deeply about the bigger picture: security, performance, deployment strategy, code quality, etc.
And that’s what I want to do in this post. In a few words, and without attempting to cover the full extent of it.
So, here are three things I’d like us to think about when we talk about performance.
Why should we care about performance?
Is it just raw speed?
How much effort should we realistically put into performance?
1. Why Should We Care About Performance?
Good Performance is an asset. Bad performance is a liability. ~ MDN, Mozilla Foundation
The quote above encapsulates the essence of our first reflection – why performance matters.
Better performance brings tangible benefits: reduced bounce rates, increased conversion, elevated revenue, and improved user satisfaction.
On the flip side, poor performance leads to site abandonment, compromised user experience, and a dip in search engine ranking.
Yet, beyond metrics, performance is inherently noticeable.
A slow website or app is a frustrating user encounter, leaving a lasting impression. In a world of fleeting attention spans, a seamless experience is pivotal.
The lesson is clear: the impact of performance is not just measured in data points but felt in every user interaction.
2. Is It Just Raw Speed?
When it comes to performance, it's not just about being lightning-fast. It's about making users feel like things are moving forward smoothly.
Speed isn't just about raw quickness. It's about creating a perception of progress. This means, for example, getting rid of unnecessary loading spinners and rethinking Server Side Rendering in serverless applications.
The key is to show users some content as quickly as possible.
Get rid of unnecessary stuff and use smart design to make your app or website seem faster, even when there is complexity (and slowness) happening behind the scenes.
In the end, performance isn't just a numbers game; it's about combining speed with how users experience that speed.
3. How Much Effort Should We Realistically Put Into Performance?
When deciding how much effort to put into performance, consider what you're building and who it's for. While there are cases where performance may not be the top concern, it rarely makes sense to build a slow web application. Even if speed isn't a strict requirement, why not make your app faster if you can?
The reality is, as I said at the start, that most of us prefer building over optimising for speed.
How much effort should go into performance?
Probably more than you’re currently putting into it
So, the honest answer to 'How much effort should go into performance?' is “probably more than you're currently putting into it”. Acknowledging this gap between what we should do and what we actually do is the first step toward closing it.
Performance optimisation is often the forgotten ingredient in the software development recipe. It's like leaving out the salt and pepper; the dish might still work, but it lacks that certain zing. ️
So, let's avoid serving up bland experiences and sprinkle in some deliberate performance enhancements. Even small tweaks can significantly improve user satisfaction, just like a dash of seasoning elevates a meal.
Here's your action plan:
Think beyond raw speed: Consider how users perceive progress. A quick glimpse of content before the full meal arrives can be more satisfying than a blank plate, no matter how fast the kitchen works behind the scenes. ️
Embrace efficiency: Trim the fat from your code and design for leanness. Remember, lighter apps run faster and happier users are loyal customers.
Invest in performance consistently: It's not a one-time fix, but an ongoing practice. Every byte shaved and every delay minimised adds up to a smoother, more delightful experience.
Performance isn't just about hitting technical benchmarks; it's about crafting software that users truly enjoy. So, let's go beyond the bare minimum and make performance a cornerstone of our development process. After all, happy users are the secret sauce of digital success.
Thanks for reading The Serverless Mindset! Subscribe for free to receive new posts and support my work.