When shopping for software, most people focus on functionality almost exclusively. They ask questions like:
- Does your program support (this feature)?
- How do you handle (this process)?
- Does your program integrate with (this service)?
This makes sense in the context of the people purchasing the software; they’re typically business owners, operations managers, warehouse managers, accountants, or other employees who use the software on a daily basis. I don’t mean to say functionality is not important, because it is ultimately what the software does that makes it valuable to a business. However, there are several important questions that few people seem to be asking:
- What is the performance of the software like?
- How does the software scale as my company grows (more parts, orders, entries, etc.)?
- What is your target response time on any given request?
These questions typically go unasked because the person evaluating the software may not realize how much of a difference these factors will make in their overall satisfaction with the product. Or, perhaps they assume their IT department will take care of this. For on-premise software, having an IT representative present during software evaluations has become more common, but still isn’t ubiquitous as it should be. For cloud-based software, clever marketing has made it seem like any problem can be solved by “the cloud” and so people presume it’s taken care of. Whatever the reason may be, I’d like to show why these questions should be in every conversation someone has when evaluating any software purchase.
What Difference Does Application Performance Really Make?
In an inventory management system like LOCATE, the average sales order is loaded ~50 times a day. Now this number is composed not only of people looking at the sales order itself, but also when we use part of a sales order’s information in operational screens as well (picking, packing, shipping, etc). If it took two seconds to load the sales order each time it is used, users would wait a collective 100 seconds per order every day. Now, lets assume your business fulfills 300 orders a day. That means on any given day, your employees are waiting a total of 30,000 seconds for sales order information to load. If your average employee is making $12/hr, those two seconds add up to $100 in lost productivity every single day. All because it took two seconds to load some basic information.
Now, let’s re-run this scenario with a more performant system, like LOCATE. LOCATE’s average response time for a sales order request is ~250 milliseconds. Based on this response time, we have reduced our average order load time to 12.5 seconds (down from 100!), times our 300 daily orders we get 3,750 seconds a day. Using our $12/hr employee from the previous example, this increase in performance results in a savings of roughly $88 per day. With reductions like this, a company could hire an additional employee in their warehouse, all because of the savings that a more performant software brings.
What Makes Software Performant?
Overall performance is the result of a number of factors in software. The most common approaches to increasing performance are adding additional computing resources and optimizing code.
Computing resources can be scaled in two ways, vertically and horizontally. With legacy type software, vertical scaling (adding power to a single, limited resource) is the only option, since these software products were designed to run on a single computer. So, the only way to increase speed and performance is to build a better, more powerful computer. Unfortunately, there is always going to be a limit on the most performant computer that can be built at any given time based on current technology and a company’s available resources. More modern systems, however, are designed to scale horizontally. This means additional computer resources can be used to share the load and speed up the software. Simply put, three computers are better than one, and 100 computers are better than three. LOCATE was designed to utilize both of these approaches to ensure sustainable and scalable performance.
Code optimization is another important tool applications can use to increase performance and scalability. With desktop software, users will often hear pushback like, “just get a bigger server” when performance is questioned. Even some cloud-based programs will reveal hidden limitations when users hit a certain amount of data. But for growth-focused applications like LOCATE, code optimization is always at the forefront of development. The developers behind LOCATE are constantly reviewing performance metrics, looking for areas of the application that might not be scaling as well as we’d like to see. From there, we review the code and look for ways to either reduce the amount of overhead or optimize the code to run more efficiently.This is how we have been able to achieve large performance increases as the application has grown. We can see the overall positive impact that optimization has on our own infrastructure and, more importantly, the consistent performance our clients experience as they scale. Saving two seconds on a process that is accessed 50,000 times a day results in a total time savings of over 27 hours.
We hope this post has inspired you to look deeper than the feature list and start asking more about performance as you shop for your next application. Because in today’s business world, seconds really do matter.
Lead API Developer | LOCATE Inventory