What if you could test a new process and IT system before implementing it? We've worked together with large organisations, figuring out a way to do just that. Agile process combined with a real user interface, real end-users, real data and real end-to-end processes. Confirm or bust the assumptions before spending years and millions.
Traditionally, large IT projects take years and cost millions. A project starts with a long requirements definition phase and it can take years before end users see the real system. The process is so long and complicated that it's difficult to keep key stakeholders interested, or even to translate real needs into documentation. Not to mention how hard it is to be innovative with this model.
The future for IT projects is already here. It's agile, fast and innovative. Unfortunately the future doesn't yet apply to all large scale IT projects. There are some perfectly valid technical and organisational reasons for this. For example complicated data migrations, having to run two systems in parallel, high number of stakeholders, and so on. Lack of a clear view of how well the end result will really work puts many large projects at risk.
Netguru Labs uses a startup methodology for piloting large scale IT projects. Our approach doesn't replace what current large IT vendors are doing. It adds agility, reduces risk and increases innovativeness of large projects. We build fully functional user facing applications with real data and real end users in weeks or months.
The magic sauce behind our approach has four cornerstones:
Agile product design. Working with startups and designing software products for them makes up our DNA. Agile processes, quick piloting, innovative development and pivoting when necessary.
Startup tools and technologies. Web and mobile applications, using the best of breed tools providing great productivity and ability to quickly change the application.
Management and technical consulting to support the process. We use design thinking principles to help the customer to come up with innovative ideas, and help confirm viability of ideas from both business and technical points of view.
Software robotics. Instead of integrations to legacy systems we use software robots for integration during our process. This allows us to move very quickly when compared to traditional projects.
We integrate with legacy systems using software robotics. In practical terms this means replacing a person with a robot. The robot uses the human user interface to read and write information to the legacy system. This allows us to avoid complicated integrations and still access all information that the staff currently has access to.
Robots read the data which is then gathered in temporary storage & business logic layer. This layer is only there to temporarily store and combine data from multiple legacy systems. The end user interacts with the data and the resulting changes are written back in the legacy systems by robots. When the end user is done the data is deleted from temporary storage.
The temporary data storage layer often also provides some processing of the data and a modern interface for the end user application. The end user uses the solution in a browser or in a mobile application.
The technical backend of our setup may be very different from a typical large IT project, but the user experience for the end user is almost identical. Because we skip the labour intensive backend changes our approach can be implemented in weeks or months, not years. For the end user the result is indistinguishable from the end product of a large IT project, just without the expensive and slow investment.
The obvious benefit is being able to test a new process and system in the real environment without actually building it. This is no paper prototype, it looks and feels like the final product with real interactions, real data and all the end-to-end processes involved.
This approach also allows to quickly test multiple different versions of a process before choosing the best one. It allows to integrate the feedback from end users early in the process. As the prototype can be run in the production environment, real issues, ideas for improvement and different approaches surface quickly. This enables fast paced iterative development of the prototype.
It's much easier to keep the participants of a pilot excited when they get to use the real system very early. No more waiting for years to see the real product. Seeing your feedback having an impact on the system in weeks is a sure way to get the commitment of the pilot team.
Effort required by the internal IT team in this process is minimal when compared to traditional large IT projects. When the pilot is done, the IT team has a fully functional user facing system. This is a great starting point for them to source the new system from their usual IT vendors, cutting back a massive amount of uncertainty also from the vendors.
While there are cases in which this approach could be used to permanently replace a large IT project this is not usually the case. Using robots and temporary data storage is often not scalable enough for more than a handful of pilot users. Using robots means much faster read-write to the legacy systems. This can cause problems with the legacy systems in large scale use. Alternatively robots need to be slowed down, which in turn leads to delays and a bad user experience.
This approach is not about creating anything technically beautiful or even sustainable. We want to define the best possible user experience, supported by the best process. This keeping in mind that the end result must be feasible both from business and technical standpoints.
There are also data intensive cases and cases with major process redesigns where the approach doesn't work because of its technical limitations. Our method also requires an environment that's either already secure or can be made secure It's better suited for internal tools.
If the goal is to use off-the-shelf application with minimal customisations, our approach is usually not ideal. We actively encourage rethinking the user experience. In these cases one of the project team members must be an expert user of the application in order to ensure the technical viability of the end result.
A private banker at a medium sized bank is spending a lot of time working with four different legacy systems. In order for her to service her customers she needs to spend quite a bit of time jumping from system to system and often struggles to answer detailed questions immediately when meeting with the customers. She has access to all the data she needs, but it's fragmented and building the correct big picture takes time.
In order to improve the situation we build a prototype application together with the bank. The application pulls all the relevant information to a single view. From the application the private banker can access all the information on her customer and show all the information on the different products of the bank using her iPad.
The prototype is built in a few months’ time and tested by a team of private bankers. Based on their feedback the tool is radically improved. The end result is a tool that allows each private banker to serve more customers, provide a better service for each of them and as a side product also improve staff job satisfaction due to eliminating mundane tasks with legacy systems.
After running the pilot for several months the management of the bank has enough data on what the impact has been for the pilot team and can compare this to other teams not taking part in the pilot. The internal IT department of the bank knows exactly what their usual IT vendor needs to build, eliminating many often uncertain and risky parts of a large project. The investment decision to build the real system becomes much less risky and the end result is pretty much guaranteed to work for private bankers.
The future of prototype-driven process development is bright. As it makes it possible to develop software in an even more agile and faster manner, it will find its place in many IT projects.