Thoughts on the role of React Native in a growth stack

Growth Hacker has been a buzzword in both the domestic and foreign internet circles in recent years. The internet giant Facebook may be the best company practicing the Growth Hacker. However, a good hype is not equal to a good result. How to implement Growth Hacker is in fact a hard-nut to crack. I recently read an article from Twitter which recommended MobileGrowthStack. This article maintains a framework for implementing the growth stack and offers help for companies that want to implement Growth Hacker. Its major output should be like what's in the following chart.


I would like to simply describe this chart. The technology stack has three levels for achieving three major objectives respectively.
• Acquisition
• Engagement/Retention
• Monetization
The realization of the three objectives is all dependent on the fourth layer - the lowest and also the most core layer: **Insight & Analytics**. So next we can look at what roles React Native plays in the process by referring to the analysis on Insight & Analytics by MobileGrowthStack.
Insight & Analytic
I still feel it is necessary to translate MobileGrowthStack's description about this layer.
The Insight & Analytics layer is the most important layer in this growth stack.
This layer is mainly dependent on a large number of high-quality data and indicators to modelize and guide growth activities in an aim to detect influences and opportunities.
Attribution of installation
In the Web world, we usually can trace users using the cookie of browsers and analyze their sources of installation. But Native apps use the unique ID of user devices, such as IDFA or Android ID. Because React Native still needs a Native shell, this part is basically consistent with the Native apps.
DeepLink analysis
Okay. The word of DeepLink is a little too trendy. I am still used to calling it schema jump. Jumping from outside of the app to a specific page in the app, or jumping from a page in the app to another page in the app can both be called schema jump. React Native actually boasts a huge advantage in this regard. The structure of Native apps is complicated. It is not easy to build a perfect schema mechanism. Taking the fast changes of current demands into consideration, it is indeed a headache to ensure the timeliness of schema. However, a little micro-innovation combining Native and React Native can make things very pleasing. Because the schema usually pulls a complete page. We can include a RootView of the React Native in this page and then carry the module name in the schema parameters, so that different single page apps can be displayed when this module pulls pages.
Other attributes such as tracing the source of schema jump are the same with Native, but much simpler obviously. After all we now have a native Module attribute to differentiate pages. What we need to maintain is only a schema link.
Event tracking
Event here adopts a general concept. You may be more familiar with the concept of tracking. Tracking means to record some operations of the user, analyze the user operations in the background and finally present the information to app developers in the form of console for decision making. React Native can reuse the Native tracking methods, as they share the same basic principles. Developers who once coded tracking all know that tracking is a very trivial task and prone to errors. When we miss something or make some mistakes, the advantage of React Native stands out, because it can modify the tracking error in real time once an error is found to make the data more accurate. This feature is of great significance.
Activity analysis
This part is actually closely related with DeepLink and event tracking. Before our promotion through activities, we need to know the objective of this activity and what the ROI is like. All these require data analysis. Apart from the advantages of DeepLink and event tracking, React Native has a more important feature - the agility in constructing activities. Because activities have their own special natures, with short effectiveness and fast changes, most of our current activities are implemented using H5. The biggest defect of H5 implementation is its poorer experience compared with Native. The emerging React Native integrates the dynamic nature of H5 and the experience of Native. That's why it exists. React Native naturally boasts a huge advantage in this regard.
App Store analysis
This part is exclusive to Native apps. App developers are often nagged by the issue of versions. Users do not want to upgrade. When the latest version is 10.0, some users are still using 1.0. No solution. React Native can solve this issue to a large extent. Because React Native is partly dependent on Native, it cannot solve this issue completely. But it has improved a lot compared with Native. Previously you may need 10 versions, but now you need only two versions to get things done. As long as users have installed our apps, we can keep making users enjoy the latest and best features, freeing both users and us from the trouble of upgrading.
ASO key word tracking
Searches for key words may be a problem for React Native. The App Store can be called a free advertisement platform to some extent. As long as I put my app in the App Store, it can be searched by users, which is free-of-charge exposure for developers. However, the diluted concept of version by React Native will efface this advantage, especially for small start-ups. However, you can still directly use the offline packages of React Native to create a new version of app and release it, writing some new key words - no one will say no to you.
User segmentation
The concept of user segmentation has existed for a long time. The simplest segmentation is to differentiate paying users and non-paying users. In general, we will provide more features or better experience for paying users. The conventional practice for achieving this is relying on the background control switch. The biggest defect in doing so is that for new users, or free users, we need to prepare many built-in features that may be used by them only after a long time, or even never used. As a result, the package size grows, which will in turn cause many adverse impacts. For me, once the 16GB server is out of space, deleting the seldom-used apps will be my first option. The advantage in using React Native is that for the features not used by current users, I don’t need to prepare the built-in code. I can enable new users to download apps at a very low cost, and gradually update the app the user uses during his/her usage so as to ensure the user enjoy more features. The premise for all these is that the background should have enough information about the user to support such a decision.
User group analysis
Grouping different users and analyzing users in finer granularity beyond the total users, MAU and DAU among other data mainly rely on data analysis in the background. This is a shared case for Web, Native and React Native.
Content analysis
Again, React Native is more convenient to provide dynamic content.
Mood tracking
Client satisfaction is very important because it is likely that some opinion leader is using the app. A negative comment from such an opinion leader may directly nip the app in the bud. Therefore, the user satisfaction survey is important and improving the comments and ratings of apps in the market is even more important. React Native can involve users in the satisfaction survey at a specific time through custom pop-ups and further guide users to leave comments in the appstore. Here the biggest difference with Native is that this pop-up displays content that can be updated in real time. You can change the content in whatever way you like - as dynamic as H5 and with the same experience like in Native. When new features and content are available, you will be able to better guide the user feedback.
User test
In the early stage of the project, user tests are usually performed by finding some real persons to test the prototype or getting a real person to the site to experience and provide feedback. In this regard, Native, Web and React Native are similar as a matter of fact.
A/B testing
The role of A/B testing for growth is beyond all doubt, or even the most important part. It is very difficult to perform A/B testing well. Reasonable user grouping, reasonable measuring indicators, and the way the A/B testing plan is designed all influence the testing result, or even the user experience.
The most traditional way of A/B testing may be the background control switch. The switch of A is on for A user, and the switch of B is on for B user. All the A/B tests must be pre-planned, then released and tested, and the result is calculated. This process is very very long, especially in iOS. It may take two weeks from approval for launch to user upgrading. This is not agile. React Native can be very helpful in this regard. Because of its dynamic nature, a page can be changed in minutes. In combination with the background user grouping, trials for errors can be conducted very quickly. React Native is nothing short of the default choice for A/B testing - fast trials for errors and fast responses.
Interface stream
In Native, the app tracking interface stream conducts tracking when the interface is shown, and conducts another tracking when the interface is destroyed. However, because of the diversity of Native implementation, it is of much trouble to track the complete interface stream. The pity is that although React Native has a schema mechanism to cope with most of the interface jumps, many interface jump issues remain unsolved depending on the actual circumstances.
Conversion Funnel
The concept of Conversion Funnel is very famous in the growth field. You can create various funnels based on the critical path to optimize user retention and experience.
Statement and revenue report
No matter what you do, you must stay sensitive to money and maintain a good record. Otherwise you are dead meat.
Growth modeling
Only by modelizing the cognition of growth in the team can the growth be inherited and constantly optimized.
User life-time value modeling
LTV (life-time value) is modeling of the value a user can create during the user's life-time for the app. It is equivalent to discount calculation.
Growth statistics
Growth modeling aims to look into the future, while growth statistics aims to summarize the current and historical data. For example,
Active users = new users + repeated users - online users during a specific period of time
Performance analysis
It is vital to track the performances of CPU, battery, network and crashes, especially for mobile users. In this regard, Native and React Native have their own respective advantages and disadvantages. For example, Native is advantageous in CPU, battery and memory performances, but React Native is advantageous in crash performance, because most of it exceptions will be captured in the JS layer, so that the issue will only cause the page unavailable, instead of making the whole app fail.
Summary
In two sentences:
• If you are already using React Native, what are you waiting for. Hurry and implement growth to be a true Growth Hacker.
• If you are trying to implement Growth, what are you waiting for. Hurry and try to use React Native.