In the fast-paced world of tech innovation, time is often one of the most important factors.
Developing software takes time, but prototypes and Minimum Viable Products (MVPs) are usually needed ASAP. At Westland, we understand the time pressures that come with innovation and proving concepts. That's why we've developed (no pun intended) an approach that solves problems quickly, whilst laying a solid foundation for future development.
Our Approach
We've developed a process that allows us to build systems in remarkably short timeframes. What's more, thanks to our methodical approach, these rapid prototypes are easily extendable into fully-fledged production systems.
There's no secret formula or magic to our approach. It's about trusting the process and years of practice. I was tempted to try and make it fit into a slick, cool-sounding acronym (R.A.P.I.D maybe?), but I think the simplicity and non-flashiness of our approach mirrors one of my favourite engineering quotes:
Our process involves five key steps:
Understanding the project requirements
Defining a scope of work
Designing the system and UI
Implementing
Testing and validating
Let's have a look at each of these.
Understanding Requirements
This is the cornerstone of any successful prototype or MVP - truly understanding what you're trying to build will ensure you're always moving in the right direction.
We work closely with our clients to fully grasp their ideas while offering our own insights and expertise to come up with a concrete set of requirements.
This is an iterative process: we define requirements, validate them with the client, refine based on feedback, and repeat until we have a clear picture of what needs to be built.
This step might surprise you - surely for a rapid prototype the best idea is to just dive in and get started. I can assure you, though, it's vital to the process. Plus, the extra time spent during this phase will save you a lot more time during development.
Once we understand the requirements of the project, it's essential to define the scope of work and cut off the fat.
Defining Scope
This stage is all about taking our validated requirements and breaking them down into smaller, manageable chunks. For each of these chunks, we determine the minimal amount of work needed to fulfil the requirement.
If we find that a given requirement would take too long to implement, we work with the client to pare it back, reducing it to its simplest form. Sometimes, we may even remove a requirement entirely if we and the client agree it's not essential for the initial prototype.
The result of this process is a formal scope of work and list of actionable tasks that serves as our roadmap for the project. With this in hand, we're ready to start designing.
Designing the System
Our design phase consists of two main components: UI wireframes and system architecture.
For UI wireframes, we start by gathering inspiration. We put together a selection of designs that align with the project's goals and use them to block out our own wireframes. Given that we're working on an MVP or prototype, we don't design the entire UI upfront. Instead, we create concrete wireframes and gather design inspiration, knowing that we can develop the finer details of the UI as we implement.
The second part is designing the system architecture. We define the discrete modules of the system and then research each to find existing libraries or frameworks we can leverage to speed up our work.
For instance, when developing the Cairn CAESAR prototype, we identified CKEditor as an excellent visual text editor we could use instead of trying to develop our own in-house solution.
You'll often find that someone has done something similar before that you can take inspiration from. Even for fully greenfield projects, you can likely still find existing tools that perform a similar enough function to be useful.
This design stage is crucial because it allows us to accurately estimate development time and gives us a clear blueprint to follow. Finally, we can get stuck in to our favourite part - programming.
Implementation
With our requirements formalised, scope determined, and designs... designed, implementation is next.
This is when we get ourselves stuck-in and start laying down some code. We hold regular progress meetings to keep our client up to date and use a shared task board so they can see the projects progress in real-time.
We like to make use of staging environments to allow our client to use the system as we develop it. We've found it's really useful getting the system into users hands ASAP.
Sometimes, you'll find that a requirement that looked good on paper doesn't quite translate in a practical sense. So, making sure users can play with the system and provide their feedback, allows you to tweak things to get them just right.
It can be tempting to cut corners and write "quick and dirty" code that just gets the job done. However, that will absolutely come back to bite you if the project needs to be taken further. Not only that, but we find there's typically no need for taking shortcuts when you've taken the time to create a robust plan and design.
A well-coded prototype is significantly easier to turn into a production system than hastily written, hacky code. And even if the project doesn't go any further, engineering is an art - take pride in your work!
As we implement, we're constantly testing and refining, which brings us to our final step.
Testing & Validation
Whilst we make sure to test during development and 'soft-validate' features in the staging environment, we also like to put time aside for a discrete testing period once development is done.
I've found it's easier to spot bugs when you're in a 'testing' mindset as opposed to when you're knee-deep in code. So, we go through the system front-to-back and back-to-front, testing out edge cases and all manner of things to, essentially, try and break things.
We use our shared task board to allow the client to indicate which requirements they consider complete. This ensures we're all on the same page about what "done" looks like.
Conclusion
Rapid software development doesn't have to mean cutting corners or producing subpar results. We deliver high-quality prototypes and MVPs in rapidly, and this process is how we do it.
Here's a few takeaways:
Don't cut corners. It might save time now (it might not even), but it'll come back to bite you down the line.
Make use of existing technology and find good inspiration for your designs. There's no need to reinvent the wheel.
Test as you go and always get regular feedback. This ensures everyone is aligned and prevents any nasty surprises later on.
Let Us Turn Your Ideas Into Reality - Fast
By following these principles, we can take you from an idea to a prototype in no time at all. If you're facing a tight deadline for your next software project, why not get in touch and let us help out.
Schedule your free consultation
Share
