Once you’ve decided to move forward with your idea, and found a software partner, you’re ready to develop your app. If you’re not a coder, or don’t have a partner who is, it’s particularly important to understand the basics of the how app development works. This is so that you won’t get taken advantage of or get off track. This post is designed to help you understand the basic process of how app development works. If you want a longer, more detailed guide, check out our new e-book, the Ultimate Beginner’s Guide to Making an App.
The Devil’s in the Details
Making an app is a lot like building a house. When you build a house, the first step is to lay down the foundation. Let’s say we plan a basement which will have four rooms, one bathroom, and two windows. Once we’ve decided on those basics, we build the foundation for the basement. When that’s done, we add the carpet, install the floor, and finish the details. Then we move on to build the first floor on top of it. After that we build the second floor, and so on.
Now let’s say we’ve build two floors on top of the basement, and then realize we want to make one change. Now we want to have a fifth room and a new window in the basement. Initially this may seem like a minor thing – that we just add some walls and a door and pop in a window. However, it is actually much more complicated than that. The floor plan may be based around load bearing structures that we can’t move easily. In reality, we may have to tear down everything we’ve built and start over. The result is that the building timeline and cost go way up.
While this is an oversimplification, it’s a great analogy for how app development works. It is critically important at the start to map out the blueprint of what the app will be. Otherwise, you can find yourself having to rebuild big parts of the app to make what seems like, to a non-coder, is a simple change.
How this Relates to App Development
Let’s use a simple example to illustrate how this relates to making an app. Let’s say you build a registration/login page. You detail all the steps, and then move on to building the rest of your app. A few weeks later, you realize that you forgot to add a “forgot password” feature on the registration page. While this may seem super simple, it’s actually not. To add this, we need to think through the logic. What happens when a user clicks on “forgot password?” Does the app send a recovery email to the user’s email address? Would the user need to confirm that they have received the email? Does the app automatically generate a temporary password and email it to the user? Should the app ask the user to confirm security questions before letting them enter a new password?
Each one of these features requires additional development. Furthermore, every additional change needs to be integrated with the rest of the code. This isn’t necessarily hard, but it does take a lot of time. The result is that going back and adding this feature can be a lot of work. And that work may require tearing down what we’ve already built and starting over. This almost always leads to delays and increased costs – precisely what we want to avoid.
The best way to avoid scenarios like this is to start off by making an extremely detailed list of everything that will go in the app. This is called listing the requirements. This is the first step in how app development works.
Requirements – the Blueprint for Your App Idea:
The requirements are a detailed list of all the components you want in your app or software. The initial draft should include anything that you may want to include, in one place. If you might want something in the app in the future, this is the time to include it in the plans. The reason for this is that even if starting small (and we think you should!) you should plan for the future. The way you build your first version should consider changes that may happen in the future. This way, when you get to that stage you can add on to the code, instead of starting over.
Think of this list as if you were describing an app to someone who has never seen one. You want to list every single feature you want to be in your app. This includes simple things, and complex things alike.
As a quick example, the requirements of a simple registration form may look like this:
- User enters First and Last Name (mandatory for user to complete this)
- The User enters email address (mandatory)
- User selects location
- The user can opt-in to share their phone’s location with the app
- If they decline that, the first step is selecting country of residence from a drop down of all countries
- The user will then enter their zip code to indicate their city of residence
- The User enters password (mandatory – must have 1 special character and 1 numeral in password)
- User re-enters password (mandatory)
- The User clicks submit (once form is submitted, email is sent to user to confirm address, after that confirmation happens the user can now login using the email and password they listed in the form)
It’s Worth Putting in The Effort Now
As you can see, even a super basic registration form has a lot of steps. In the requirements list, it is necessary to get into this level of detail for every single feature and section of the app.
The initial requirements will be a long and detailed document. The requirements are like the detailed blueprint for your app. This document includes every feature that will go into the app. For more specific tips on how to write requirements click here. Remember – if something isn’t in the requirements, and is added later, it is almost surely going to add to the cost and timeline of the development. Once we’ve done the full requirements list, we almost always recommend narrowing down the key features that you consider to be “must haves” and to consider starting with just these.
Once you have your requirements, you need to make sure that what you want to do is technically possible. The feasibility study is confirming that it is possible to make the idea happen. For example, let’s say that your idea is to make an app that will let you print any picture from your phone onto toasted bread. For the feasibility study we would need to research if any toasters have Bluetooth technology and the ability to process data from phones. Once feasibility is confirmed, you’re ready to move on to the next steps in how app development works.
Setting Up the Architecture
Your app is going to need an infrastructure to support it, which we’ll refer to as the architecture. Your app and user data need to live somewhere. This will be with a hosting company/server. Think of this like a garage for your car. Amazon Web Services and Digital Ocean are two of the most common of these. The architecture and development environment are the foundation upon which we will build the code that makes up your app.
Wireframes are basic visual outlines of how the user interacts with the technology. These are not final designs, but rather outlines of what goes where on the phone screen. For example, the wireframe for the settings menu of your app will indicate where each item will go, and in what order. Here is a helpful guide to check out if you want to learn more about wireframes.
Front and Back End Development
This is when the work actually starts towards building your app or software. Front end development basically means building the things that the user will see on their screen. This includes the visual look and design of the app, the user interface. This includes things like the button styles, icons, colors, logo, and fonts.
Back end development refers to the stuff going on behind the scenes. This includes things like storing data, how to process algorithms, etc. The back end and front end talk to each other. When a user clicks a button on the front end, the app tells the back end what action should be taken.
These are slight oversimplifications – fore more information check out this helpful article.
When building an app or software both of these are equally important. It is also important to note that often software developers tend to focus on either front end or back end – which is important to keep in mind when building your team.
Testing is crucial in app development, and it is an ongoing process. Every time a feature is built, it is important to test, and retest, and then – you guessed it – test again! The nature of app development is that bugs pop up all the time. The only way to fix them is to identify them, replicate them, and figure out the solution. It is absolutely normal for bugs to appear, especially in early versions of an app.
Your software partner should do testing every step of the way. You will also have a chance to test the app, and can do this on your own or ask friends/coworkers to help. Another option is to hire a company to test for you. You will always find errors, or bugs – that’s to be expected! It is important to do many of testing and get as many eyes on the app as possible so that you can list these and fix them. Remember to test using different devices (Android, iPhone, tablet, laptop, different web browsers, etc.) and to try every feature in the app. For more information about the testing process, check out this.
Once you’re confident that the app is ready to go to users – it’s time to go live! This means making the app publicly available (or available to a limited test audience). Keep in mind that you will need to go through approval processes to get into the Apple Store or Google Play Store. If you want to know more about what goes into the approval process, check out Apple’s process, and Google’s. Some of this stuff may sound confusing – your software partner will be happy to explain the steps.
We hope you’ve found this post helpful to better understand how app development works. Remember, you can always feel free to contact us by emailing firstname.lastname@example.org or using this form.