Training employees to use enterprise software can present some significant challenges, security issues, and threats to data integrity. Enterprise software includes CRM (Customer Relationship Management) and ERP (Enterprise Resource Planning) applications. Frequently the solution is to use screen captures and animations to simulate the user interactions required for various business processes.
However, typical software simulation applications, such as Adobe Captivate or Articulate Presenter, do not readily provide the full range of documentation needed to support an enterprise software implementation. In addition to interactive transaction simulations, support requirements usually include materials for both classroom and Web-based training, performance support that users can access while using the application, user guides, and user certification. Ideally, the implementing organization would like to be able to create all these deliverables before launching the application and releasing it to users. And getting the deliverables developed with a minimum of time and effort is also highly desirable. Needless to say, this is a challenge!
In this article, I will introduce you to the Oracle UPK (User Productivity Kit), which is a software simulation application with the ability to create in one capture a number of different deliverables, including:
- On-line and classroom training materials, including application simulations,
- Job aids,
- User guides,
- Test scripts (that is, scripts for testing the software),
- HP Quality Center files, and
- Other content needed to ensure user adoption.
This article is not a tutorial on the UPK (although I will provide some high-level information about the product’s functions and method of use). Rather, I focus here on use of the UPK in the context of a software implementation project. In other words, I will outline a project management approach, using UPK, that will reduce content development time and cost, create the needed user training materials, performance support, and certification, and will support definition and testing of user transactions – all before “go-live.”
What is the UPK?
At the end of 2008, Oracle bought the software branch of training company Global Knowledge, including a product known as “On Demand Personal Navigator.” Now rebranded as the Oracle User Productivity Kit (UPK), the software has a name that sounds rather industrial, but at least it’s less generic than it was.
Oracle (http://www.oracle.com/applications/tutor/user-productivity-kit.html) describes the UPK as “a collaborative development environment to create system-related assets – the ‘People to System’ documentation.” In other words, UPK helps document business processes and enterprise software (i.e., CRM, ERP, and similar systems). It does this by recording interactions with the user. The UPK can assist various stages of enterprise software implementation, including the training stage, but is by no means limited to just training.
Originally, UPK was designed to capture business processes in Oracle applications (by recording interactions between user and software), and to provide documentation for implementation and production operations. It can also be used with a number of Oracle-supported products, including:
- SAP
- JD Edwards
- PeopleSoft
- Siebel
As an example, this summer (as of June, 2009), the State of Connecticut is implementing the UPK to provide users of CORE-CT (core financial and administrative computer systems) with demonstrations, practice tools, and simulation-based assessments. The first exercises released were for processes within the Accounts Payable, Inventory, Asset Management, and eProcurement modules of CORE-CT.
A developer can install the UPK as a single-user, stand-alone application on one machine. Installed this way, the UPK does not require a connection to an enterprise database. You can also install the UPK for a multi-developer environment. In this latter case, it does require a back-end database for content data. Ideally, Microsoft IIS will be part of the development server in the multi-developer environment. However, if IIS is not available, the Oracle database is supported.
UPK simulations are full-screen DHTML slideshows. They appear as a screen recording would. IIS is not needed for deployment of the player, which is a separate browser-based application. (Incidentally, some users create their simulations with UPK, and then import them into Articulate Presenter for delivery. They seem to prefer these results to using the UPK Display tool.)
You can download a trial version of the Oracle UPK from http://edelivery.oracle.com. (There is a similar application, Simbuilder, which is also available as a trial version from the same site. I mention this in case you want to compare the two for your needs, but I will not address Simbuilder in this article.)
Features
UPK is much more expensive than Adobe Captivate, one of its competitors, but it is not intended for the same uses as Captivate. UPK supports large-scale deployments. It is SCORM-compliant. It has the ultimate goal to provide a coherent, maintainable, up-to-date training solution, usually through a Learning Management System (LMS). By contrast, Captivate doesn’t support usage tracking properly, and is used more on small initiatives.
The only common, important feature that UPK doesn’t have is automatic recording. Recording an interaction with UPK requires a number of separate steps. When ready to begin recording, the developer must start the recorder and then use the Print Screen button to capture all screens and actions. The developer should think in terms of taking a lot of screen shots, rather than too few. For example, the developer must remember to capture all the pull-down menus in Oracle forms. Also, it is important to capture screen shots from other applications that the enterprise app may use, such as MS Word or MS Excel. You can use UPK to capture PowerPoint slides for use in creating explanation frames. UPK also supports placing callouts (Oracle calls these “bubbles”) to explain actions to learners. The explanation frames and bubbles give users the detail they need to understand the process. Editing out mistakes is not difficult.
While this sounds complicated, from a training developer perspective, this is good. It gives you more flexibility to capture exactly what you want. Just remember to hit “Print Screen”!
Development
There are two parts to UPK. The Development Tool (the subject of this article) is the means for capturing interactions and creating the various outputs. The Display Tool is a separate application, a player that delivers the finished slideshows.
The hierarchy in UPK is a directory structure:
Title → Module → Section (or Lesson) → Topic
The Development tool opens in the Outline editor. Each Title must have at least one Module, one Section, and one Topic. The content developer creates these, and records the content for each Topic. In addition to the screen captures and bubbles, the developer also enters descriptive information into two important areas on the associated property sheets: the Concept and the Introduction (more about these a little later in this article).
Learner modes
UPK offers four basic modes to the learners:
- See It! – This mode allows the user to passively watch the transaction being performed.
- Try It! – This is the preferred mode. Using this mode allows the user to interact with the application. It simulates the production environment.
- Know It! – This mode tests users on the knowledge they gained from the training. Users complete the steps for a particular task, and UPK gives them a score, based on how accurately they complete them.
- Do It! – This mode is available in the production environment. It’s an embedded help that can be displayed when the user needs help performing day-to-day tasks.
Best practices for deploying the UPK
I like to keep things simple, so here are three things that will make your UPK deployment easy.
- Remember, it’s all about the Plan!
- Create a common, shared set of training development guidelines and standards.
- Test the material and prepare logistics.
It’s all about the Plan
One of the most common questions in managing the instructional design component for enterprise application development projects is, “When should I start developing the training content?” To answer this question correctly, it is important to understand that training development is part of the change strategy in IT projects.
Change management and training development
Change management is often perceived as that 10% tax at the end of IT projects. This is sad, because change management should instead be one of the triggers of an IT project. Figure 1 shows how change management should be positioned in projects, almost as a consulting group.
Figure 1 Change management is a consulting function in project management.
As part of the change strategy, training development should therefore begin when the project begins. In deploying UPK, the training curriculum should be designed when blueprinting the project deliverables. It is at this point that you will identify the elements that UPK calls Modules and create a library. The library will be your Modules repository. Then, when alpha and beta development commence, training developers should start drilling down the curriculum, creating Sections and Topics within the Modules, or simpler sub-Modules.
During the beta phase of implementation, the training developers should start playing around with the various functions of the enterprise application, in order to get familiar with it. We have even seen projects where training developers were reporting almost 50% of the bugs!
Subject Matter Expert strategies
A very important task in this phase will be to decide the Subject Matter Expert (SME) role that best fits the project. There are two cases:
- The SME can show the training developer how the software works, including all the transactions. The developer records (captures) the transactions and creates the explanatory frames, the bubble texts, and other details needed to support user learning and performance. The SME reviews and approves the content after development, so that both the developer and the SME review the content, or
- The SME can develop all the content.
I don’t recommend the latter approach, for various reasons. One reason is that in most cases the SME will be overwhelmed with project activities and will push training development until the last minute. Another reason is that the SME doesn’t necessarily have the skills or the knowledge of pedagogy required to develop training material (whether e-Learning or not).
Actual training development
Development of the actual content – Modules, Sections, and Topics – should begin when stable versions of the software move into testing environments. By waiting to do this until actual working software is in testing, if changes occur to the application, they are usually minor and there will be fewer content items to change. One can easily make the changes, either by using UPK to capture the modifications, or by using Paintbrush and editing the screen shots manually. The latter method is faster.
Resources: How many developers will I need?
This is the question on every project manager’s mind. One hour of final training content requires about 40 hours of development work. A fairly large ERP implementation will require about 400 instructional topics, which means over eight weeks of actual training development. (Remember, “Topics” in UPK are the actual content containers: screen captures and text.) For this amount of work, the recommended UPK development team will be composed of a lead and around five developers. These figures will scale, depending on the size of your project. The time-estimate figures include review, editing, QA, sign-off, and publishing stages.
Managing the development lab: Versioning issues
In order to avoid conflicts, two versioning strategies are possible.
The first strategy, which is by far the best, is to assign topics to people. This way, one person is accountable for one topic. The accountable individual can interact with the appropriate SME, and there are no possible versioning issues.
In some cases this is not possible, and that is when the second strategy should come into play. Use the Oracle document check-in and check-out feature. This feature is offered on the Enterprise version of UPK. If you are using a stand-alone version of UPK, my recommendation is to set clear file naming conventions, using dates, initials, and transaction names, combined with a strict follow-up (an Excel spreadsheet will do the job) to know who has what, who owes what, and by when.
Create a common, shared set of training development guidelines and standards
At the heart of UPK is the trainee, and when you don’t want to lose a trainee, you have to be coherent. UPK development standards should be one of the blueprint deliverables if you don’t want your content to be completely heterogeneous.
I use this checklist when a UPK project starts.
- IT requirements
- (a) Hardware is very important for UPK. The Development Tool consumes a lot of memory. In addition, we have noticed that some SAP Web-enabled applications also consume a lot of memory. Therefore both developer and user computer specs have to be clearly defined and tested up front.
- (b) Screen resolution is also very important. In most cases I recommend using 800x600 so that the finished product will fit every screen. Even though today most displays are running in 1024x768 and up, having the full screen application in 800x600 will put a blue border around the simulator. I really like this because you know you are not missing any part of the screen. This is not always possible; I saw a traffic control simulation that was working on 1680x1050 screens, using every possible bit of the screen. When trainees would play it back, they had to scroll every frame horizontally. This was not convenient, but it was the only option because trainee desktops were 1024x768. Once you set up the proper screen resolution, don’t forget to switch before you start capturing!
- Graphic design standards
It is a fact that people use their eyes to learn. If you want your training content to be coherent, set clear standards regarding graphic design, and don’t be afraid to set them down to the very lowest level. I personally like to use a table to organize the specifications. (See Table 1 for format.)
- Wording principles
- Advanced UPK features usage
- Player Package – This format will publish the various playback modes associated with UPK (See It!, Try It!, Know It!, and Do It!).
- HTML Web Site – This format will publish a series of static Web-based HTML files.
- LMS Package – This format will publish SCORM-compliant content grouped as a package to be distributed by a Learning Management System.
- System Process – This format will publish a business process Word or PDF document.
- Job Aid – This format will publish a step-by-step aid in Word, or as a PDF document.
- Training Guide – This format will publish Module, Section, and/or Topic overviews created as Web pages in UPK, a step-by-step guide with screen shots, and a Table of Contents.
- Instructor Manual – This format will publish Module, Section, and/or Topic overviews created as Web pages in UPK, any included instructor notes, a step-by-step guide with screen shots, and a Table of Contents. Each topic is a separate Word or PDF document.
- Test Document – This format will publish a procedural guide for use in testing an application.
- HP Quality Center – This format will publish a document suitable for exporting into HP Quality Center.
|
|
Static Graphics |
Video |
Sound |
Title Font |
Title Text |
Etc. … |
|
Modules |
|
|
|
|
|
|
|
Sections |
|
|
|
|
|
|
|
Topics |
|
|
|
|
|
|
What you will say is also very important. Titles should clearly communicate the content of the Modules, Sections, and Topics. Since UPK allows long titles (63 characters), the Titles should describe the element as completely as possible. I also like to start the Topic Titles with the names of the transactions, for example, “MM01” (in SAP).
The Concept gives the user the information that is needed to complete the procedure. The developer enters this text in the “Concept” area of the UPK property sheet mentioned earlier. Document any prerequisite topics in the Concept, too. This description should also contain a link to the Job Aid document generated by the application. The text that the developer enters in the Introduction area of the property sheet will appear in the Introduction frame.
You should always standardize the wording of the Concept area and the Introduction area. Always start the paragraphs the same way. For example: “In this module you will learn how to … this will be achieved through doing … and … The key learning points are …“
UPK offers a lot of advanced options. Choose the ones you need, and set standards for them. Always use the glossary when introducing a technical term. Limit the use of alternate paths and decision frames; this feature is really cool but impossible to maintain – make just one change to the application and you have to re-capture two paths. Finally, set the outputs you want to generate; they should completely align with the change strategy (e.g.: do you want to test users, do you want to give them one-page job aids or full user guides, and so on).
UPK offers these outputs:
Test the material and prepare logistics
We can never say it too much – practice makes perfect. Other users should test the training material (or, as we say, QA it). These should be users that have little knowledge about the project, not just the Subject Matter Experts. In addition to providing you with good feedback about your content, it will also create a buzz around the project.
At this point, you will tweak your content. You will also specify the grade required to pass the test in Know It! mode. The grade required can vary from application to application. However, remember this one bit of advice about testing: the more text the user has to type, the more chances you will have that every trainee’s text will be different, and the lower the passing grade should be. On the other hand, if the transaction is only based on mouse clicks, the passing grade should be 100%. And, of course, you have to combine that with the chosen user-adoption requirements included in the change strategy.
A second important point that people tend to underestimate is the logistics. When preparing your change strategy, think of the training rooms, the format (instructor-led or self-paced), printing, burning CDs, and possibly shipping if the company has several locations.
Summary
UPK is a wonderful tool. When implemented well, it provides powerful training and knowledge-sharing tools. On the other hand, without good planning and simple governance, UPK can quickly create disruption, confusion, and duplication. In my work experience, I have seen both sides of UPK. I wish I had more space and time to explain about maintaining and updating the training material, as well as training development and testing strategy integration, and many other UPK issues you might be facing. I hope to address these in a future article!
