Architecture for Rapid Implementation of Enterprise Systems
ARIES is a methodology for rapidly implementing complex large-scale enterprise software systems, including multifacility, regional, and national systems.
Many large-scale IT projects fail for a very simple reason: they take too long. They get mired in complexity and overly bureaucratic processes, costs escalate, and the client loses confidence. Often, the result is that a fraction of the system goes live and is declared a success, but the scope of what is implemented is too limited to provide the intended benefits.
Another common cause of failure is that methodologies and schedules are too rigid. According to the Harvard Business School book Managing Projects Large and Small:
Conventional project management methodologies work best when the chances are really good that the project will unfold as anticipated during its planning stage … when there is not much genuine discovery going on. … 50% [of large IT projects] are outright failures.
Complex IT projects rarely unfold as originally planned. It is easy for projects to get trapped in overly formal processes with rigid schedules, so there is no hope of meeting deadlines unless the projected time frames are excessively (and unacceptably) long.
Many implementation methodologies (especially those used by consulting and systems integration firms) are designed to implement custom-built applications or products that cannot be easily adapted to the client. Custom-built solutions can be very time consuming — for the client staff as well as the software provider — and often do not provide adequate functionality. When implementing inflexible products the client needs to adapt to the product, which is often referred to as “implementing best practices”. This approach is also very labor intensive for the client’s staff, and again may not produce the desired results.
ARIES is based upon a different premise: that complex information problems are best (and in many cases can only be) solved with sophisticated software products that can adapt to the client’s unique requirements. Such products are a prerequisite to using ARIES.
ARIES can be used in combination with most project management disciplines, such as PMI and PRINCE2, and tools such as Pert and Gantt charts. However, it does not work with methodologies derived from, or primarily intended for, manufacturing, process control, or evidence-based processes. Such methodologies are typically not sufficiently agile for complex software implementations.
- Adaptability. While it is natural to want to change some client processes during the implementation of a new product, extensive client procedure changes are best performed either before or after the implementation — not during it. The key to ARIES is a product that can rapidly adapt to the way the client operates, rather than forcing the client to change. Thereafter, the adaptability allows the system to grow and evolve as the client evolves.
- Client Executive Involvement. The very definition of an enterprise system implies that it will have a dramatic impact on the enterprise. Without constant executive involvement by the client, there is little hope of success.
- Early Client Feedback, Iterative Processes. The “waterfall approach”, which assumes that each stage of a project must be completed before starting the next, is not a practical model for rapid implementation. Projects work much better with an iterative approach in which client feedback occurs early and continuously as the system configuration is refined, and in which multiple milestones are pursued simultaneously.
- Rapid Adoption. ARIES emphasizes quickly getting users a fully functioning system, and then making additional changes in regular intervals over the next 90 days, based upon user feedback. Too many projects get mired in endless loops of requirements proposed by users before they have any practical experience with the product.
- Client Validation, Not Testing. When installing a product, there is no need for the client to test the product — it has already been tested. There is, however, a need for the client to review and validate that the configuration, workflows, data migration and integration, and any special reports reflect the client’s needs. This validation results in a set of go-live certifications.
- All-At-Once Go-Live. An “all-at-once” approach in which the whole facility goes live with the complete system at the same time (or over a period of a few weeks) usually works best. It avoids duplicate data entry into both the old and new systems, and partially implemented systems often provide inadequate functionality to operate effectively. Most importantly, it provides benefits of a fully functioning system to the client much sooner.
Appendix I: ARIES Implementation Steps
The steps in an implementation are as follows:
- The first meeting with the client is used to build a relationship, establish the overall expectations of the client, and identify client resources. This meeting should include the executives who participated in the purchase of the system as well as the key client personnel involved in implementing it. The user adoption campaign is introduced at this point, and a joint team is identified to roll it out.
- The Country Edition of the product (or another version close to the client’s needs) is shown to the client users who have been identified for the project. This demonstration is to reinforce how the product addresses their needs and to get users thinking about how they can best use the system.
- Application Specialists gather specifications for workflow and other configuration issues, and the client signs off that the specifications are what are being requested. If there are multiple hospitals/ organizations, then all of the organizations should review each module at the same time.
- Similarly, Technical Specialists work with Application Specialists and the client to identify (and get client sign-off on) special reports, integration, data migration, and any necessary custom development.
- Based upon client discussions, InterSystems provides a set of patient-journey use case test scripts.
- Starting with the Country Edition (or an implementation that is similar to the hospital/clinic, etc.), InterSystems implements all of the workflow and software configuration changes and creates most of the site-specific code tables. The client makes no workflow or configuration changes but may be responsible for some of the code tables. Many of the changes are made while the client responsible for that module is sitting with InterSystems personnel.
- The configuration is presented to the client who tells us if we have made a mistake in anything (such as having the wrong workflow) or left out anything important, and we will then make any necessary corrections.
- At the same time, Technical Specialists are completing integrations, data migrations routines, reports, etc.
- If there is any custom development, it is reviewed and tested by the client. If there is any user interface for the custom development, it also should be reviewed and approved by the client.
- InterSystems (or a subcontractor) runs our test scripts.
- The client reviews and validates: a) the workflow, clinical rules, and other configuration components; b) data migration, integration, reports, etc.; and c) any custom development. The client also runs and validates the patient-journey scripts. Steps 7 through 12 are iterative!
- Go-live certifications are obtained for each module separately and for data migration, integrations, and a set of patient-journey use cases. There should also be a go-live certification that the client IT infrastructure is adequate.
- InterSystems trains the client “super users” and system administrators. Training of the other users is performed by the client or by a subcontractor.
- The system goes live (usually the whole system goes live at the same time or within a few weeks), and users begin getting experienced with the system.
- At the end of the first 30 days of live usage, we provide any essential changes. InterSystems will assign staff to work with the Client Help Center during these 30 days.
- At the end of 90 days — after go-live — we install a final set of changes. At this point the system should be ready to be supported by the support organization.
Appendix II: ARIES Milestones
The following is an example of a set of milestones for a single-facility ARIES project. (A similar set is used for a multi-facility project.)
The iterative and parallel nature of activities means that milestones will not always be completed in a predicted order.
- Project commencement
- Major specifications are obtained and agreed upon (with sign-off by the client)
- System environment is ready, including all IT infrastructure
- Configuration is completed
- Reports and dashboards are completed
- Integration and data migration routines are completed and validated
- Test scripts run successfully
- Go-live certifications are completed
- Super user training is completed
- User training is completed
- Completion of the first 30 days of live usage – adjustments are installed
- Completion of the first 90 days of live usage – final adjustments are installed and the system is turned over to support
Appendix III: ARIES Responsibilities of Parties
The following chart provides an overview of joint responsibilities in a large-scale implementation for a healthcare client. This may be different for different countries and different clients.
|InterSystems Responsibility||Client Responsibility|
|Data Migration & Integration||
|Testing & Validation||