How to Accelerate Implementation with a Rapid Prototype

Hack your way to an efficient and successful PSPA Implementation.

Read this introduction to the advantages of including a rapid prototype in your implementation strategy.

Rapid Prototype

A rapid prototype is a quick, collaborative, time-boxed experiment that attempts to implement a new retirement plan or significant plan rule changes in an isolated development environment for the purpose of assessment, planning, and risk mitigation.

Overview

Implementation of a new plan is an iterative process of discovery, experimentation, testing, and refinement.  This can be further complicated when adding a plan to an existing customized implementation. Since each retirement plan can be different in so many ways, it can be rather unpredictable how well a plan will fit the configuration capabilities of the delivered PSPA application.

Developing a working prototype in a standalone environment is the fastest and safest way to get started with the implementation.  As time allows during the prototype phase, the prototype will be iteratively refined and expanded to include additional and more accurate functionality for an increasing number of scenarios.

Prototype Tasks

The prototype phase might include a preliminary conversion of a subset of data for a subset of the member population, if necessary, and begins to implement plan rules from end to end.  Increasingly complex or exceptional cases will be tested while refining segments of the process to get closer and closer to expected results for all cases.  This process assembles a framework for periodic and calculation processes, and gaps are quickly identified, resolved, or documented. 

The process ends with a working prototype for core processing functionality that can be demonstrated to the team. Another outcome is a clearer understanding of outstanding development or data cleanup efforts that will be required. Subsequent project phases then have a solid base to continue refinement and develop integrations for a robust workflow.

Scope

The prototype can be considered the initial implementation phase for the core processing and calculation components. It may work for upwards of 80% of cases.  The design is documented for detailed review and refinement at the end of the prototyping phase.  The outstanding scenarios will be better understood in preparation for the planning, design, and development required for full implementation. 

The general scope of the prototype phase is to demonstrate the periodic processing and calculation processes for a small subset of members. Only a basic data conversion of required data from the legacy system is performed.  The goal is to match the legacy system results or have a clear understanding and documented gap explaining why the prototype results don’t match. 

The prototype phase will be time constrained, so the scope or completeness of functionality within these two processes may vary depending on the level of fit.  If time allows, the scope can increase to include various integrations that execute the processes or utilize results from the processes, to demonstrate more typical and complex workflows.

Prototype Goals

The primary goals of a prototype phase are to quickly:

• Convert the basic member data required for the periodic and calculation processes.
• Implement plan rules, first with an emphasis on end-to-end breadth and then with increasing depth and accuracy.
• Identify challenges that will need to be overcome – either during the prototype or scheduled for the full implementation project.
• Bring together the implementation team to transfer knowledge
• Establish the ability to demonstrate working processes and review tangible results.

Prototype Resources

Resources in the following roles are required to complete a Rapid Prototype:

Administrators

Administrators help define and prioritize the project scope. They allocate and mobilize the resources needed for the prototyping exercise. They provide materials, such as plan rule documents, legacy system data, and access to a prototype environment. During the prototype, administrators share their knowledge about the plan and legacy systems, add to their knowledge of the PSPA application, and collect pertinent project planning inputs.

Users

Users help identify the appropriate prototype test population and scenarios. They provide validated sample calculations and expected results for testing. Users learn about the PSPA application during the prototype and assist with reviewing prototype results.

Implementers

Implementers set up the new configurations for the prototype, test configuration capabilities, and identify challenges and gaps. They iteratively resolve configuration errors and refine configuration for greater accuracy. Implementers learn more about the plan rules and legacy systems during the prototype and compose configuration documentation.

Developers

Developers convert legacy system data and develop solutions to identified gaps and other issues. During the prototype, Developers learn about legacy system data structures. Developers are responsible for conversion mapping and scripts, customizing the PSPA application, and composing development documentation.

Designers

Designers assist developers with the design of solutions for larger gaps, especially where PSPA expertise is beneficial or prior solutions can be leveraged. It’s important to fit new development into the PSPA design paradigm for maximum flexibility and supportability. Designers learn about legacy system workflows and compose development documentation.

Prototype Benefits

There are many benefits to using a Rapid Prototype phase as part of a complete implementation plan.

Identify and Assess Implementation Risks

The overarching goal is to implement the retirement plan rules and processes successfully, but there are some risks involved in achieving this goal. Identifying and finding ways to mitigate the risks is critical to success. The prototype phase can help uncover significant risks early or even defuse risks. Prototyping can clear up some unknowns or introduce new surprises. The results help focus leadership attention and resources on the appropriate challenges and risks:

• Highlight gaps that may be difficult to solve.
• Expedite business rules or policy clarifications and administrator decisions that may be required.
• Analyze data issues that may require compromise or additional resources to resolve.
• Propose change management opportunities to smooth the transition between systems.
• Clarify resource skillset gaps.
• Mitigate any internal resistance to change.
• Assess confidence in the PSPA solution.

Create a Solid Implementation Foundation

Prototype participants may begin with varying visions for how the system will be configured and how workflows will be performed. The prototype phase helps to resolve these differences and establish a working prototype:

• Begin bridging the knowledge divide between the plan rules, legacy system, and PSPA system experts.
• Create foundational conversion mapping – helps create a roadmap for more robust conversion programs with validations and error reporting.
• Create foundational working implementation – provides a base for refinement and enables integrations and extensions to be more thoroughly designed.
• Establish KPIs, test cases, expected results, and test result comparison methodologies.
• Experience how gaps ebb and flow – gaps that seemed like they would be hard might turn out to be easy to solve, and rules identified as a fit might be surprisingly hard to implement – the prototype activity helps clarify.
• Build experience with process execution and error resolution.

Collect Implementation Planning Data

The goal of the prototype phase is not to develop a complete, fully functioning, 100% accurate system but rather to collect data to be able to create a work plan to fully implement the system accurately.

• Identify risk mitigation efforts that will be required.
• Document system gaps or confirm prior Fit/Gap Analysis, collect additional gap details, experiment, and refine possible solutions for more detailed work estimates.
• Capture outstanding configuration, or fit items, to be estimated.
• Gain knowledge to predict resource capabilities and efficiency and understand staffing, training, and timeline requirements.

FAQs

Why start with a prototype?

An agile approach is effective for finding the ideal intersection of data, business rules, workflow, and exception handling within an existing highly customized COTS system needed to implement a new Plan. The traditional waterfall approach to implementation attempts to identify and design all business rules configuration and gap development solutions up front but is often sent off-course by surprise system functionality constraints and misunderstood requirements.

By rapidly deploying a prototype, the hidden and exceptional requirements, data availability and quality issues, and many other types of surprises are identified early. They can be resolved earlier with less redesign, documentation revision, and project plan extensions.  Having a working prototype to refer to when designing extensions will help different teams to evolve the same understanding of how the system will work holistically.

Why start with the PSPA Periodic and Calculation Processes?

These processes are foundational to the PeopleSoft application and can be the hardest to implement.  Data required by these processes can help clarify the scope of data to be included in conversion and employer reporting functionality.  The outputs of these processes inform how new retirement benefit claims will be passed to the pension payroll and how current benefit recipients will need to be converted.  These processes need to be established before workflows that use them can be fully designed, such as the processes and system capabilities for member data corrections, service purchases, contribution validation and billing, and withdrawals.     

Should all business rules and processes be fully implemented in the prototype?

The time allocated to the prototype project phase should be limited, and likely not all rules and processes will be implemented. Remember, the goals of the prototype are validating system capabilities, discovering functionality gaps, and experimenting with possible gap solutions.

The scope should be initially limited and appropriately prioritized. The scope should be focused on configuring and customizing delivered PSPA capabilities. This is where the challenge of implementing rules and customizations is greater than areas we know from the onset must be custom developed.

Depending on the progress achieved during the allotted prototype project timeline, the scope may need to be adjusted up or down. The scope that can be achieved will vary depending on the size of the team and the skills and experience level of the resources involved.

Can the prototype configuration and development be used for the final implementation?

Yes. The configuration changes and development can be integrated into the production path. Overlap between the prototype development and any production development during the project timeline will need to be resolved, and thorough regression testing is recommended. The test cases and expected results collected during the prototype phase can be carried forward to regression test implementation in a new environment.

The working prototype will provide a foundation for the development of workflows and processes that directly interact with these core processes.  The prototype configuration and development can be directly carried forward to subsequent implementation phases and is not throw-away work.

Commentary

Think of prototyping as a hackathon for your Pension implementation. As someone whose job is to get things working and solve pesky problems every day, prototyping represents anti-procrastination. Experimenting with configuration and development helps achieve a deeper level of thinking and solutions than simply designing on paper can.

The sooner you dig in, the sooner you get to a solution, and the sooner you can forget about a troubling problem. You save energy by not carrying the burden of uncertainty for longer than necessary. Starting early gives you more time to refine the solution based on results and feedback. Reserve documentation effort for exactly how expected results were attained, not what you think might get you the expected results.

Building and fixing is infinitely more fun than planning, estimating, and documenting because the feedback loop is much faster, and the results are tangible. The solutions developed tend to be better, provided you remain willing to refactor with any major design changes.

The same strategy is applicable to developing enhancements. Start experimenting with a ‘good enough’ idea and quickly find alternative paths for maximum usability and flexibility with each iteration. Quickly get to a final design that far exceeds designs only on paper.

Additional Resources

Continue reading with the details of a recent real-world case study to understand the rapid prototyping methodology better. The case study covers typical prototyping activities. A representative overview of the implementation challenges encountered and solutions implemented on a pathway to successful implementation are also included.

Rapid Prototype Case Study Articles

• Important Background
• Outcomes and Executive Summary
• Test Population
• Test Automation
• Configuration Challenges
• Errors/Resolutions
• Prototype Conversion
• Gap Development
• Delivered Application Issues
• Array Sizing Issues
• Design Discussion