With all business-critical projects, proper execution is essential to success. This may seem like a simple generalization, but the reality is that most enterprises are unable to get a project over the line in a proper timeline.
This is the driving reason behind the creation of SCORE, which stands for Solution Centered Rapid Execution Process. It’s more than just a good acronym, it’s actually a core part of what we do and how we can provide a holistic and transparent approach to software development that you won’t find anywhere else. That’s because we put the solution first and then tailor the whole approach around it, meaning the variety of approaches we can take are truly whatever is necessary to getting the result that’s desired. It’s a flexible approach to project implementation, just modular enough to let us handle the delivery of projects of nearly any size by taking a modular approach.
The flexibility is a key part of what makes SCORE special. For starters, we don’t tailor the approach around one methodology. Since all clients have different approaches to software development and implementation, we’ve made a point to focus on building SCORE in two ways: Iterative or AGILE. We’ll save the AGILE based approach for later; In this blog post we will focus on taking an Iterative-based approach to SCORE.
To really explain the iterative based approach to SCORE, we’ll need to fully explain what a waterfall-based software development projects. It’s maybe not the greatest name ever created to describe a development cycle, but it’s without a doubt one of the most popular methods of development and implementation and one used worldwide. Each “waterfall” is a moment in the development timeline that represents a switch from one stage from each other (e.g., transitioning from research to planning). Each one of these moments of transition come with certain stage gates that surround implementation, often times check points for acceptance by the client. To continue the previous example, a waterfall moment would be verifying the research is complete and makes sense to the client, which would allow the next step, of planning the solution, to begin.
The waterfall approach comes with a lot of positives that can benefit the client. For starters, it’s incredibly familiar, originating in the mid 1970s when complex development cycles were being theorized academically. Next, the beauty of the waterfall approach is that all client requests and the scope of the project are agreed upon early, which provides an easy lens to gauge the success of the project at any specific stage. And once the scope and requests have been verified, clients don’t need to be involved in the development stage (if they want to be, great!), since the pathway to success has been laid out.
For our iterative approach to SCORE, we leverage the flexibility of the waterfall approach to creating 4 distinct stages with 3 main waterfalls for client involvement. A key reason we take the waterfall approach is to adapt to our customers’ methods and approaches to software implementation. As opposed to some of our competitors, we are happy to let clients stay engaged in the project and peer into some of our implementation moments. The four main stages we have labeled as follows: Prepare, Execute, Launch, and Review, and we will examine each of them below.
The first key stage is preparation. This starts in a way that we’re all familiar with, and really, are trying to get more familiar with our client and their desires. Initial engagement efforts lead to a complete proposal with a kickoff meeting, evaluating logistics, and conducting risk analysis. This leads to a comprehensive planning stage as we workshop out the requirements, evaluate what processes are “to be” or be left “as is,” and evaluate all the requirements. From there, we conduct another workshop to flesh out the design of the solution, the source systems, interfacing, and analyze any and all gaps. This triggers the first waterfall moment, requiring a client review.
From there, the execution phase begins as we begin a cycle of building and testing. Our team starts building the solution for an initial user, inputting the required variables and scenarios, and builds out the first workable model for the solution. This is a highly subjective phase as the inputs, business modeling, and unit testing are completely dependent on the client requirements. When the solution is built in its first iteration, we migrate it to test servers for rigorous testing, another key waterfall moment. First, we will test the execution and resolution capabilities of the solution and try to examine the possible issues along the way. We try to grab a member of the clients’ team, preferably the expected true power user of the solution, early into the testing to gather their thoughts and teach them the inner workings of the solution. This also acts as an early education phase, allowing us to “train the trainer” and pass on the knowledge. After we’ve achieved a reasonable degree of familiarity with the solution, we prepare it for roll out and go through final user acceptance testing, checking off every last box.
With that last box checked, we’ve officially moved through the final waterfall and into the Launch Phase. We then begin to migrate the solution to production, rolling it out to the client and their eventual users. Here we provide in-depth documentation and technical training to the required users, and making sure that no stone is left unturned for any of the users, ensuring proper familiarity, and let the client begin to truly embrace and utilize the power of the solution. After the solution is running properly, we begin to compile a retrospective and evaluate the key learnings from the project.
By putting the solution and client first, SCORE ensures a project is successful from the very beginning. The iterative approach described above is a perfect example of how a classic approach to software development can ensure a well-built solution and, above all, happy clients. In our next blog post we’ll look at how SCORE is applied in an Agile methodology… Stay tuned!