To make sure your apps are well built, easy to maintain, and serve the needs of the business, it's important to follow the best practices on this list.
Most of us think about apps that run fast, run well, and meet specs when it comes to "supercharging" them. But there are also some basic blocking-and-tackling techniques that application developers should keep in mind to ensure that their apps stay optimized and well regarded by those who use them.
1: Include end user testing and acceptance in your QA
Application quality assurance testing that includes user testing for usability and functionality before app deployment betters the chances of low application maintenance and enhancement immediately after the app is launched in production. This is where you want your app to be. You don't want to be redesigning and redeploying it while other work continues to wait in the queue.
2: Use good test data
I can remember times when, as an application developer, I had to work with incomplete records and dirty data. It was frustrating because you never really knew if every edit and function in your app really worked. App team leaders shouldn't allow this to happen. Instead, they should insist upon clean test data so they can really run an app through all its paces. It is the only way you can be sure that the app is going to operate correctly in a production environment.
3: Have great specifications
Before designing any app, specifications for the app should be clearly documented and understood by the business and IT. There are many reasons to run short pilots and prototypes for an app proof of concept. But when it comes to a final app design, code and test — the way the app is going to look, how it is going to perform, and the information it is going to deliver to the business must be very clear. It is up to the IT application project manager to review specifications developed with end users for completeness and signoff before serious app design work gets underway.
Developers are notorious for doing the least amount possible when it comes to documenting their work, but IT app managers and those who run QA should insist upon it. Why? Because IT spends 50% to 60% of its time in maintenance mode, including the maintenance of applications. When a maintenance programmer has to go in after the original developer to modify an app, documentation of what has already been done becomes very important.
5: Include security and governance requirements in your app specification
App developers routinely incorporate standard security and governance requirements in their apps. This works fairly well most of the time. Nevertheless, security requirements are more granular than they used to be. The app developer needs to know not only who is authorized to use the app, but which areas of the app are open to which individuals. Often, these precise security needs surface only when an app is about to be deployed. If they are known up front, the security design and its ultimate maintainability over time can more effectively be optimized.
6: Use standard application programming interfaces
Platform portability is the name of the game in app development today. Always use standard APIs when you're integrating your application with other hardware and software. Hand-coding a custom interface and then having to change it is one of the most difficult programming jobs there is.
7: Build apps with reusable objects and routines
This is standard practice in most shops. It includes reusable objects and routines for commonly used operations like getting date and time stamps, invoking security routines, and using precise business logic that is applied across many applications. Reusable objects and routines save time and build consistency. They also reduce the potential for error.
8: Perform a thorough integration test
When app development time runs short, there is a tendency to focus on the unit test and to short-change end-to-end integration testing. If the app doesn't work with every piece of software and hardware it accesses, these problems will certainly surface in production, where it can adversely affect the business.
9: Don't forget stress testing
Programming annals are filled with war stories about apps that performed beautifully in a test QA environment and then couldn't carry a large or unforeseen transaction load in production. Consequently, the apps failed when the business needed them most. IT resources are limited, and a full dress-rehearsal test that emulates an environment of huge transaction loads is often hard to set up. Nevertheless, app developers should never feel comfortable about placing an app in production without thorough stress testing, especially in businesses in the hospitality, airline, banking, retail, and stock brokerage industries, where the inability to handle large volumes of transactions can result in losses of millions of dollars of revenue.
10: Prototype often
Even when your app is just in a preliminary stage, it is wise to get the end users engaged in reviewing the app for usability, appearance, etc. It's easier to make adjustments earlier in the process. By engaging the end users early, the app developer also avoids the possibility of unpleasant surprises when an app finally gets delivered and it isn't what the end user expected it would be.