DEV Community

Cover image for App Store Review Rejections: A Performance Budget Approach
Amit chakraborty
Amit chakraborty

Posted on Originally published at amitchakraborty.dev

App Store Review Rejections: A Performance Budget Approach

The Situation

Say you are a mobile app developer, tasked with improving the performance of your React Native application to meet the App Store's review guidelines. Your team has been receiving vague feedback from reviewers, stating that the app is too slow and needs to be optimized. The symptom is a rejected review, which costs your team time, money, and potential users. Each rejection delays the release of new features and bug fixes, resulting in a loss of revenue and user engagement.

Why It Happens

The App Store review process is designed to ensure that apps meet certain standards for performance, security, and user experience. However, the review guidelines are often vague, making it difficult for developers to pinpoint the exact issues with their app. The "make it faster" feedback is a common example of this vagueness. Without a clear understanding of what "faster" means, developers are left to guess what changes will satisfy the reviewers. This can lead to a trial-and-error approach, where developers make arbitrary optimizations, hoping to stumble upon a solution that meets the review guidelines.

The Fix, Step by Step

To turn the vague "make it faster" feedback into a measurable ceiling, the team can follow these steps:

  1. Establish a performance budget: Define a set of key performance indicators (KPIs) that measure the app's performance, such as startup time, frame rate, and memory usage. For example, the team can set a budget of 2 seconds for startup time, 60 frames per second for frame rate, and 100 MB for memory usage.
  2. Measure the current performance: Use tools like the React Native Debugger, Xcode, or Android Studio to measure the app's current performance and identify areas for improvement. For instance, the team can use the React Native Debugger to measure the startup time and identify bottlenecks in the code.
  3. Set a performance ceiling: Based on the measured performance and the established budget, set a performance ceiling that the team can defend. For example, the team can set a ceiling of 1.5 seconds for startup time, 50 frames per second for frame rate, and 80 MB for memory usage.
  4. Optimize the app: Use the performance ceiling as a guide to optimize the app's performance. This can involve optimizing images, reducing the number of components, and improving the app's architecture. For instance, the team can use a library like react-native-image-optimizer to compress images and reduce the app's size.
  5. Monitor and maintain the performance: Continuously monitor the app's performance and make adjustments as needed to maintain the established ceiling. This can involve setting up performance monitoring tools, such as New Relic or Datadog, to track the app's performance in real-time.

What It Costs, and When Not to Do It

Establishing a performance budget and defending it can be a time-consuming process, requiring significant resources and effort from the development team. However, the benefits of a performance budget approach far outweigh the costs. By setting a measurable ceiling, the team can ensure that the app meets the App Store's review guidelines, reducing the risk of rejection and the associated costs. Additionally, a performance budget approach can help the team to identify and prioritize performance optimizations, leading to a better user experience and increased user engagement.

However, there are cases where a performance budget approach may not be suitable. For example, if the app is still in the early stages of development, it may be more important to focus on feature development rather than performance optimization. In such cases, the team can defer the performance budget approach until the app is more mature.

At Your Level

  • Starting out: Focus on understanding the App Store review guidelines and the importance of performance optimization. Start by measuring the app's current performance and identifying areas for improvement.
  • Working engineer: Take ownership of the performance budget and defend it. Use the established ceiling to guide optimization efforts and ensure that the app meets the review guidelines.
  • Senior or staff: Develop a comprehensive performance strategy that includes a performance budget, monitoring, and maintenance. Ensure that the team is equipped to defend the performance ceiling and make data-driven decisions.
  • Lead or director: Ensure that the performance budget is aligned with the company's goals and objectives. Provide resources and support to the development team to establish and defend the performance ceiling.

In the Interview

When interviewing for a mobile app development position, the candidate may be asked to explain how they would approach performance optimization for a React Native app. A weak answer might sound like: "I would just use a bunch of optimization tools and try to make the app faster." This answer is weak because it lacks a clear understanding of the App Store review guidelines and the importance of a measurable performance ceiling.

A strong answer, on the other hand, might sound like: "I would establish a performance budget and defend it. I would measure the app's current performance, set a performance ceiling, and use that ceiling to guide optimization efforts. I would also ensure that the team is equipped to monitor and maintain the performance ceiling, using data-driven decisions to inform optimization efforts."

The follow-up question might be: "Can you give an example of a performance budget you've established in the past, and how you defended it?" This question separates candidates who have actually implemented a performance budget approach from those who have just read about it. A candidate who can provide a specific example, including the metrics used to measure performance and the optimization strategies employed, demonstrates a deeper understanding of the topic and is more likely to be successful in the role.


Amit Chakraborty is a founding engineer and senior architect — React Native, AI/RAG systems and production architecture. Portfolio: www.amitchakraborty.dev · LinkedIn · GitHub. Open to senior and founding engineering roles, remote worldwide.

Top comments (0)