We make decisions during software design and development that will determine the success or failure of our apps. That’s a daunting thought. But many teams like yours look to a team like ours to guide you through the process. Here are some of the things we suggest you think about along the way.
Decisions Made Pre-Kickoff
Approach
One of the most important decisions you make upfront is choosing the right development approach for your product. We’ll explain the differences between Native, Hybrid and Web and when you should use them.
Native applications are built for one platform, usually Android or iOS, in the native language intended for that platform. We use Kotlin for Android and Swift for iOS. Native apps can take full advantage of a device and operating systems’ features. This development approach offers the best user experience and is best for consumer-facing apps, or for when you want to use all of a device’s unique features.
- Better UX
- Immediate and unrestricted access to native APIs
- More secure
- Easier offline capabilities
- Persistent brand presence on screen
Responsive web applications are developed using technologies such as HTML5, CSS, JavaScript and Dart. We build web apps using AngularDart. Web apps render in a phone’s browser and can access some of a device’s native features, but provide the least pleasing user experience. But a web app is great for reaching non-smartphone using customers. They are also useful for prototyping software before investing a lot of money into an unproven concept and for users who work from a desk.
- Reaches wider audience
- Cross platform reach
- Relatively quick and inexpensive to develop
- More availability of developers
- Search Engine discoverable
- Some offline capabilities
Hybrid applications are web-based while wrapped in a translation layer that gives access to some native mobile features. PhoneGap and Ionic are popular hybrid frameworks. They market themselves as a cheaper, faster way to build software because they can be deployed on multiple platforms. This is useful for internal products that don’t need a rich UX.
Hybrids also don’t stand up to native when it comes to access to new developer tools. iOS and Android developers get access early, as they are building natively. Hybrid frameworks are sometimes several months behind, if they integrate a new feature at all.
Platforms like Xamarin and Appcelerator package an additional library of code that maps Android and iOS native code to another language.
- Cross platform reach
- Easier for search engines to find
- Access to most native capabilities of the device
- More availability of developers
- Persistent brand presence on screen
- Some offline capabilities
Flutter, a newer SDK from Google, uses Dart, a language we love that we also use for server-side development with our open-source framework Aqueduct. These approaches offer the most premium “hybrid” experience.
Tech Stack
Can your legacy system support modern software development, especially for complex integrations like Internet of Things systems? It’s time to find out.
Why is evaluating your tech stack important? Companies that have been in business for years already have complex systems in place that power many business processes. These systems (or tech stacks) were not built with modern software or Internet of Things capabilities in mind. They are also often fragmented, not providing enough visibility into a company’s data that most modern businesses need.
So how do you determine if your stack is ready to support mobile apps?
Modern applications tie into the cloud which is where logic and behavior is computed. A modern tech stack uses REST APIs (Representational State Transfer Application Program Interface), a cost-effective solution for interfacing between apps and web services. REST separates the user interface from the server and database, improving the scalability of your apps. REST also can be used with many types of servers as long as requests are made with XML or JSON. If your stack already supports Rest APIs, you are in a good place.
Discovery
Discovery can save your team cycles and budget by reducing risk. Through user research, we can test and validate our assumptions, and define a product roadmap.
“The price of light is less than the cost of darkness.” – Arthur C. Nielsen, Market Researcher & Founder of ACNielsen
Now that you’ve determined what development approach to take, and you understand your existing tech stack and if it will support your app development efforts, it’s time to go through Discovery.
We can make fairly accurate guesses about what a user wants, especially if we know our customers, but without testing our concepts with users, we’re bound to make mistakes with our assumptions that could be easily avoided.
On the technical side, discovery allows us to evaluate existing code, plan scalability and define approaches for tackling development challenges.
Budget
Software design and development costs can add up. Where do those costs accrue? Let’s take a look at the many pieces that can impact your timeline and budget.
The average cost of developing an app is $200,000 and takes between 3-4 months to build.
What impacts cost?
- Number of platforms, backend
- Number/complexity of features
- Third-party integrations
- Available resources
- Phased approach vs. all-in
There are also some things to consider to avoid project pitfalls.
- Moving into development without discovery & research
- Not having the right talent
- Failing to test
Decisions Made During the Project
Planning
At the start of your project, you’ll need to decide what features will bring you the most ROI immediately. You’ll also need to determine what tools you will use during design, development and testing.
Feature Prioritization – What’s the most important thing you can do for your user? Prioritize features that provide the most value and deliver on your business objectives.
Tool Selection
- Issue management
- Automated tests
- Continuous delivery
- Buddy build
- Data Collection & visualization
- Analytics gathering
Execution
Respect your timeline. This is the most important thing you can do to make sure you deliver on time and on budget. The second most important thing to ensure success is testing, both the code and with users.
Respect your timeline. Your roadmap will evolve at a macro level, but don’t make quick changes during the middle of a sprint. This leaves important features behind unfinished and creates technical debt resulting in damage to your timeline.
Reflect. Test. Verify. Reflect, test and verify decisions made at the end of each sprint. Get your product to end users to test quickly. Automate testing and save manual activities for high-value actions. The more feedback the better.
Decisions Made Post Launch
Usability Testing
Companies and designers are not the user. We can make assumptions about what users want, but without usability testing, we don’t have the data to confirm our assumptions are correct.
Feedback
Once you’ve conducted usability testing, it’s time to incorporate your user’s feedback. The more you respond to user requests, the happier your users will be.
Support and Maintenance
With software, nothing is ever finished. There will always be new operating systems, feature releases and other feature integrations that need the attention of your development team.
Ongoing Costs
Ongoing maintenance and support require setting aside a budget for post-launch upkeep.
Analytics
Take a look at your analytics. See how user data relates to your initial product objectives to make sure your product is delivering the results you need.
Don’t lose momentum
Once you’ve pulled the right team together and pushed out your first release, now isn’t the time to stop development. Keep the momentum going with the team who has the institutional knowledge of your product.
Conclusion (TLDR)
1. Always do discovery
2. The right tools make all the difference
3. Respect your timeline: Stay focused on ROI-producing features
4. Test. Test. Test.
5. Understanding builders vs. maintainers
6. Managing ongoing costs
7. Measure & Refine
8. Maintain momentum: Don’t stop developing between phases
