Ever wanted to know how to make an app? Here’s the short answer.
Let me start by saying – making an app isn’t easy. There are various ways to go about it but each and every method requires skill, passion and determination. This is especially true if you want to do it right and develop a high quality app.
In this article I’m going to break down the app development process that we use at DreamWalk. This is a fairly typical process, not unlike that used by many app development agencies around the world.
This is NOT a programming course but rather a high level insight into the steps required to take an app from idea stage through to a live app on the app stores.
The steps required to make an app are:
- Workshop the idea and strategy
- Document the requirements
- Design the user experience (UX)
- Design the user interface (UI)
- Create a design prototype
- Develop the back end
- Develop the front end
- Test the app
- Debug the app
- Deploy the app to a live environment
- Release the app on the app stores
- Maintain the app post-launch
We use an agile methodology which means these steps don’t always happen in this particular sequence. Often multiple steps will happen concurrently and we’ll loop back and forward between them in an iterative fashion.
So, let’s take a look at how to make an app in a bit more detail.
1. Workshop the idea and strategy
During an in-person or online app strategy workshop, the development team discusses and fine-tunes the app concept with the client. This involves deeply understanding the target audience and business goals of the app and ultimately mapping out the features and user stories or flows of the app.
2. Document the requirements
After the workshop a business analyst will document the outcomes of the workshop and fill in any missing details in the preparation of a Statement of Work (SoW). An SoW is essentially a plan of attack. It is a detailed explanation of how the app should function, as agreed to by all parties. Its important to make sure the expectations of all stakeholders are aligned before app development commences.
3. Design the user experience (UX)
The design process is broken into a few different phases. The UX design phase is when the product designers determine how the user will move through the app and what will be included on each screen. The goal here is to map out a simple and intuitive experience for the user. The outcome of this phase is usually a set of wireframe designs. These are basic sketches showing what goes where but NOT what the app will actually look or feel like. Those visual design decisions are made in the next phase.
4. Design the user interface (UI)
The UI design phase is sometimes referred to as the visual design phase. This step involves the designer taking the UX wireframes and turning them into a visually appealing user interface design.
A logo design and brand guidelines, including typeface guide, colour palette and patterns are a prerequisite of this phase. The designers will usually complete a brand design phase before commencing UI design if branding has not been provided by the client. A comprehensive set of brand guidelines gives the UI designer direction and helps ensure consistency across the many screens of the app design.
5. Create a design prototype
It is common for designers to create a design prototype once user interface designs are complete or even during the UX or UI design process. This enables the client and stakeholders to click through the design, like they would the finished app, before any development begins.
Prototyping is a great way to iron out any remaining UX issues and perfect the design of the app before time and money is spent on development. A prototype is also handy for getting feedback from others by way of user testing.
6. Develop the back end
In most cases the development of an app is broken into two distinct processes. Back end development and front end development.
Back end app development refers to what goes on behind the scenes. The database, scripts, processes and algorithms that the user doesn’t see. The back end usually lives in the cloud and feeds data between the app and the database.
Back ends are built using web frameworks like Node, Angular or Elixir and require a very different skill set than front end development.
A backend is only required for apps that have user accounts, apps that need to store data online or apps that share data between devices and users.
7. Develop the front end
The front end is the part of the app the user can see and interact with. It is installed on the user’s device and usually receives content or data from the backend using what we call APIs.
iOS apps are written in Swift or Objective C while Android apps are written in Java. Frameworks like React Native or Flutter enable programmers to write a single code base and export it to both Objective C and Java. This way the app can run on both platforms without needing to be written twice in two different languages.
Some apps are front end only and don’t require a back end. These are usually simple static content apps that don’t have user accounts.
8. Test the app
Apps need to be tested throughout the development process to ensure features and functions perform correctly. This testing can be done manually by humans or programmatically using automated tests. Manual testing is more popular for startups due to the lower cost while automated tests are often used by larger corporations to test mission-critical functions.
Beta testing and User Acceptance Testing (UAT) are some of the final test phases in a project, whereby the client confirms that the app meets their requirements.
9. Debug the app
All apps have bugs. Bugs are unavoidable becasue software is written by humans and humans are imperfect. One tiny spelling mistake or misplaced comma among 20,000 lines of code can cause an app to function incorrectly.
Some bugs are more destructive than others. A big bug can cause the app to crash or fail to load. A small one might just result in a slight visual misalignment or it might even go completely undetected.
Most bugs are usually uncovered during testing and fixed during debugging. Debugging can happen at any time during development. Essentially, whenever tests reveal bugs, the issues are sent back to the developers for debugging.
10. Deploy the app to a live environment
During development and testing, an app and its code exist on what we call a dev or staging server. Here, the data can only be accessed by the developer and stakeholders but not by the public. This is important because development may not yet be finished. Once development is complete and the app has been thoroughly tested and debugged, it is ready for deployment to a live environment.
A live environment is a server that enables public access to the app. This does not mean that the general public can access the server or the code directly. It just means that the publicly available app can access data and write to the database. This public access is required for users to be able to create accounts, share information or download resources, for example.
11. Release the app on the app stores
In order to publicly release an app it must first be submitted to the relevant app stores. The most common are the iTunes App Store for iOS apps and the Google Play Store for Android apps.
To be able to submit an app to these stores, you’ll need to subscribe to the relevant developer program. Google charges a once-off, $20 fee to become an Android developer while Apple charges an annual $100 subscription fee to be a part of their developer program.
Submission of a new app to these stores is relatively straightforward but does require some app development knowledge to generate the app builds and certificates required.
Apple formally reviews all apps to confirm that they meet the Apple developer guidelines before approving them for release on the App Store. Google don’t formally review all apps submitted but will take down apps that are reported as being in breach of the guidelines by other users.
12. Maintain the app post-launch
Post-launch maintenance is possibly the most overlooked phase in the app development process It is a critical factor in the life of any app.
After initial launch, an app will start to collect real user data and feedback. It is vitally important that this data is analyzed and revisions are made accordingly. Very rarely will an app be perfect from day one. In the vast majority of cases, an app will evolve to better serve its target audience over time.
There may also be more bugs uncovered once the public starts using the app. New operating system updates and device launches could also make app updates necessary. Launching a successful app is never a set-and-forget process.
Those are the steps typically involved in the development and release of an app. In a standard ‘waterfall’ development process, these steps would happen in a fairly linear fashion. In an agile process, the steps are completed in a more non-linear manner. For example, at DreamWalk we usually work in sprints. This means we will design, build, test and debug a set of screens or features, then deliver it to the client for feedback before moving on to the next batch of functionality (sprint). We’ll then loop back through those same four steps to deliver the next batch of features. We repeat this process until the app is finished and ready for deployment and release.
At a high level, this is essentially how we take an app from idea to app stores. Each and every step in the process requires very specific and specialized skills and experience. This is why most apps are built by a team and not by a single person.
If you have any questions about the process we are always happy to answer them. Drop us a message at https://dreamwalk.com.au/contact
Shout out to Kika Fuenzalida for the beautiful illustrations.
Got an app idea?
Let’s chat about how we can help bring it to life using our proven formula for success.