Modifications, code fixes and configuration changes to production systems are a necessity on a software implementation project. A formal testing procedure is recommended when major changes are made, but sometimes testing is minimized for smaller changes. Unfortunately, small changes can also lead to system outages and user frustration if not properly vetted or if key startup procedures are missed. Systems today are so complicated that even simple fixes can break existing functionality due to a relationship not documented or not completely understood.
One way of mitigating the risk of outages caused by minor changes is to develop a standard production system Smoke Test. This smoke test should be performed after any change is made, but before all the users are given general access to the system. It would be ideal if the person performing this smoke test was independent of the group that had made the change or was not the group that stayed up all night long resolving the problem.
Generally, smoke testing happens after formal testing, but in the case of minor system changes, formal testing may be considered unnecessary. The use of a “smoke test” in this case gives the systems group an early warning to issues that might easily be addressed before full production is resumed. Provided below are some examples of the tasks to be included in the standard smoke test.
Standard Smoke Test Tasks:
1. Validate essential business processes
- Perform a sales order from Quote to Cash
- Perform the procure to pay cycle
- Do an inventory transaction
2. Validate essential system interfaces
- Run a sample credit card transaction
- Test out a transaction using the tax interface
- Test out EDI interfaces
- Run a workflow
- Test an alert
- Run a batch job and have it send out an email
- Verify the help functionality works
- Test the enterprise portal
3. Validate essential peripheral devices
- Run reports in batch and print them
- Check inventory using a hand-held device
In summary, a Smoke Test is a good practice to ensure that essential system functionality is validated after any change. The result should be more productive users and less system frustration.