SearchClose.png

Know Your Inputs - Technical To-Do's for Deployment Success

Those who have been through or studied a technical implementation likely know all the phases of the Software Development Lifecycle by heart and have a firm grasp on the outputs of each phase. Interesting to note, though, is the number of folks who have never asked, or even pondered, what the actual inputs are for each phase of an implementation.

Ask any implementation consultant: What problems do you face during a technical implementation?

The answer? A familiar refrain: incomplete requirements, scope creep, lack of SMEs…the list goes on, and these items repeatedly impede a successful implementation. With preparation, typical pain-points can be lessened or even alleviated altogether. Knowing the entrance criteria to each phase of the SDLC is the difference between a long, painful implementation and a smooth, exciting challenge.

For each stage of the Workday project lifecycle – Plan, Architect, Configure & Prototype, Test, Deploy - know what you need to have BEFORE you enter that stage. Here’s a checklist, broken down by stage.

What you need pre-Plan:

  • A list of current business processes: You will be better prepared if you have a list of business processes showing what they are, who performs them, and what exceptions there are to them.
  • Key attendees for design sessions: Include your process owners and functional experts; they know the processes and who should be in the room.
  • Defined management hierarchy: Time and again we’ve seen how a lack of clear ownership can hamper a project before it even gets out of the planning room.
  • Existing vendor documents: Get your business requirements documents ready. This is information you will have to have eventually, and it’s easy to obtain from your vendors.
  • Notify your 3rd party system owners: If a change is coming, contact your vendors and internal system owners to let them know. It’s amazing how helpful some vendors and system owners can be!

What you need pre-Architect:

  • Project charter: Complete a project charter and have the project sponsor ready to buy into it. Identify guiding principles and publish them to all of the project stakeholders.
  • Thoroughly designed documentation: These designs give your functional and technical partners a clear blueprint to follow for their implementation and remove any ambiguity in your needs.
  • Functional and technical owners: Assign a small group of people to be responsible for knowing the processes, owning the work, and finding answers to the questions which will inevitably surface.

What you need pre-Configure & Prototype:

  • Access to key systems: Your implementation team and 3rd party vendors need to test key integrations to ensure a test environment is ready and available before starting development and testing.
  • Key vendor contact(s): Know who to call when there is a question or need before your team starts building.

What you need pre-Test:

  • Testers for each test stage: Identify a group of SMEs who can test the system. This is critical to any implementation. Enlist people who know the typical cases, the exceptions, and the really weird use cases with enough forewarning that they can identify and remove competing priorities.
  • Test scripts: Leveraging SMEs, a project team can have their test scripts together well in advance of testing. In fact, having the test scripts can provide great insight as early as the planning stage of your project.
  • Signed off test strategy: This includes System Test logistics (who, when, where). At the very least, these should be the outputs from your architect phase.
  • Vendor resources for testing: It takes two when there is a system integration; ensure your vendors and third party system owners know what to do with the data once they have it, and well before you start sending them test files.

What you need pre-Deploy:

  • Finalized global support structure: Make sure you know how you are going to support the system once it is live.
  • Vendor certification of integrations: The vendors must agree the data they are receiving meets their requirements. There is no point in deploying a solution that the vendor cannot work with!

Keep these checklists-by-stage handy: this will help you tremendously when you are going through a deployment.

TAGS: Best Practices, Software-as-a-Service, Uncategorized, Workday, checklist, deployment, development, implementation, inputs, integrations, lifecycle, outputs, software, technical, Workday