Blog Post How does no-code support design thinking?

You may not be familiar with the words ‘design thinking’, but that doesn’t mean that you haven’t engaged in its process in some shape or form.

The process follows five phases, but while these are all vital to the methodology, they are also fluid and non-linear. So, rather than following a set process, you:

• Seek to define your users’ problems and needs
• Find innovative solutions through prototyping and testing
• Continue to question assumptions and reconsider problems as you go

It’s an approach that we integrate into everything we do at App Rail, so much so that it’s become part of our DNA. We don’t always shout about it explicitly when we are developing apps with clients, but it’s always there in the background.

This approach helps us to shape the way we engage with our customers’ teams and ensure the apps we build serve the needs of the end users.

The five phases of design thinking

To fully understand what design thinking is all about, it’s worth starting with an explanation of the five phases involved.

1. Empathise

At its core is the idea that you must empathise with your customer and stand in their shoes. That's the lens through which every single decision is made. So when you're bringing your product to market, every choice you make is as relevant to the customer as possible.

By focusing on the users’ needs in this way at all times, your end product or service becomes meaningful to them and helps them accomplish their goals.

2. Define

In the traditional model, a tech project often tends to be managed as one big piece of work. The whole thing is created in its entirety and then released in one go with fanfare. Often, the team behind it then discovers it’s not what the customer wants, and a lot of time and money is required to make it right.

With the design thinking approach, you start out by 1) admitting that there’s a lot you don’t yet know and 2) accepting that there will be failures along the way.

In contrast, the Define phase is about stepping back. To define well, you need to learn to put assumptions aside, so you can properly understand what problem you’re trying to solve and clearly set out your users' needs. It’s not about specifications documents or lining every detail up perfectly. Rather, ensuring that the direction the project begins on is the right one for success.

3. Ideate

Having defined the key direction, the next step is to freely explore how user needs can be addressed. Later, we take time to narrow things down ready for delivery. But this time is spend making sure we’ve considered different options and aren’t just committing to the first idea or one person’s view without cause.

Because the process is non-linear, be prepared to be spontaneous by developing new creative ideas each time you redefine your users’ needs.

4. Prototype

This is the exciting bit where you take your creative ideas and start to develop them into real world solutions for your users’ needs. But, because you aren’t developing the whole project in one go, each prototype can address a specific aspect of your overall product.

The key to prototyping is iteration. We put the first flow together as quickly as possible, as a working digital sketch, if you will. We can easily improve details, move elements around and even consider alternative approaches. App Rail makes this really quick and easy to do without much technical expertise.

5. Test

Once our prototype is ready, we can take time to circle back around to our products’ users and test it long before committing precious resources to finalising the product and going to market.

Often, all we need is to iron out any nagging usability issues but, sometimes, we are encouraged to go back to the drawing board and consider a better way to solve the problem. While uncomfortable in the moment, it prevents much bigger failure later on.

Key to this is involving users’ feedback and opinions at every iteration:

• Is it working for them?
• What would make it a better experience?
• Does it solve the original problem?

The testing phase involves going back to these points every time you prototype and embedding the users’ points of view within every change that is made.

Integrating design thinking into no-code

As long-term believers and users of the methodology, our founders developed App Rail with the principles of design thinking at its core. And with so much common ground between no-code and design thinking, it wasn’t difficult to marry the two.

No-code is a platform that allows non-developers and developers alike to develop tech products using a graphical interface, instead of writing code. It’s the perfect partner for design thinking – it's iterative by nature and highly intuitive, putting power into the hands of the creator, even those with little or no technical expertise.

And it’s quick. Using no-code means you can apply design thinking to easily build and test an app within hours – not the usual weeks or months. Developing prototypes this quickly means that changes can be made to individual aspects of the app easily and efficiently, so you can iterate naturally, often without even realising you’re doing so.

How App Rail works with design thinking principles

Let’s look at a few examples of how App Rail’s no-code solution takes in the principles of design thinking by breaking down the different stages:

• Empathise/define – Translate common design methods like sketches, user interview insights and flowcharts into prototypes and continue to use these to empathise and define with users
• Ideate/prototype – Build prototypes and put ideas into tangible and shareable material very quickly by dragging and dropping functional pieces of an app into a flow that works
• Test – Unlike design prototypes, App Rail prototypes are functional and can be put into users' hands or even given to them to use. You can see how they will be used in real life and make iterations very quickly, get new ideas and put them into practice – then repeat

Many organisations have woken up to the idea of design thinking. But while it’s something they want to embrace, it can be difficult to achieve. This might be because they get caught up in the theory of design thinking, or struggle to follow its principles beyond the beginning stages of building an app. Often, it’s a promising methodology that’s met with lack of resources or time on the ground. But App Rail changes all that.

With no-code, you can hit the ground running by diving straight into the things that get you results. App Rail provides a tangible tool to make design thinking happen inside organisations. It helps to take the theory and turn it into reality when it may have been challenging or impossible before.

Get in touch to arrange a 30-minute demo to find out more about how App Rail uses design thinking principles.