React Native for Beginners: Create React Native App in 5 Steps

A Guide to Create React Native App 

Before we start, in this five-step guide, we will know how you can start your React Native development journey. This guide is for those who are just starting with React Native and provides an overview of react native mobile app development. 

Let’s get started. 

1. Solidify Your Foundation

React Native is a JavaScript-based framework that enables experts in web development technologies to create modern and native-like mobile apps. You will need a team that is proficient in JavaScript-based technologies. 

They should know the core concepts of React, such as JSX, state, and props. We have highlighted these features of React Native in one of our articles, “What is React Native?” In addition, there are some other concepts, such as understanding ES6+ syntax and asynchronous programming. 

You will also need to know layout systems (Flexbox and Yoga) and platform-specific APIs. 

This first step is to solidify the foundation and concept that you need to work with React Native. 

If the developers are familiar with the basics, it may take around 3-6 months to learn React Native and build an app. Outsourcing is a popular approach today where businesses can hire expert React native developers to build an app.  

Brilworks is a top-rated React Native development company, a house to expert react native development, providing developers for hire. If you are looking to hire expert and experienced React Native developers to build your app, you can hire developers on different models such as per project, pay per hour fixed price, or dedicated for an indefinite time. Are you curious about the cost to build React Native app from scratch? Check out our comprehensive guide on "React Native Development Costs" to get all the details.

Let’s come to the point.  What else will you need to create React native app? 

2. Choose Your Development Environment 

If you're familiar with the React Native concept, you'll need to set up a development environment. In simpler terms, you'll need an editor, a platform, and some services to run React Native apps on your system.

To get started, 

1. You'll need to install Node.js on your computer, which is essential for creating React Native apps. 

2. Additionally, you'll need to install the Expo CLI and a code editor like Visual Studio Code. These are the fundamental tools required to build a React Native app.

The first step is to install Node.js, followed by the Expo CLI. Once the Expo CLI is installed, you can create your first project by running a command:

npx create-expo-app@latest MyApp

This will create a new project folder named "MyApp" containing the basic files and code for your app.

After creating the project, open it in Visual Studio Code. As you write code in the editor, the Expo CLI will monitor for changes. Whenever you save your code, Expo will automatically update your app on your device or simulator. This way, you can see the changes in real time.

If you're comfortable with the basics and want to build more advanced features, you can use the React Native CLI. It provides more flexibility and control for custom, complex apps.

So, you have two primary options: Expo for speed and simplicity, or React Native CLI for depth and control. 

Also read: Managing React Native Environment Variables

3. Design Your App's Architecture

App architecture is critical for scalability. If you neglect it, it can become an obstacle when you add new features or app scales. Software architecture is what helps you maintain the software’s quality attributes. If you put your efforts into making solid architecture 

Component-based architecture is a popular and effective approach for React Native mobile app development. In this paradigm, developers create reusable components that can be reused anytime during development. This architectural style is so popular because it streamlines code maintenance for large-scale projects.

app/

│

├── _layout.tsx             # Root layout (global layout for the app)

│

├── tabs/                   # Tab-based navigation

│   └── _layout.tsx         # Layout for tabs

│

├── home/                   # Home tab content

│   ├── _layout.tsx         # Home layout

│   ├── index.tsx           # Matches route '/'

│   ├── details.tsx         # Matches route '/details'

│

├── components/ # Reusable UI components 

│   ├── Button.tsx

│   ├── TabSelector.tsx

│   ├── Header.tsx

│   ├── Avatar.tsx

│   └── ... # More components

└── settings.tsx            # Matches route '/settings’

3.1 Props and State

Ensure a clear flow of data within your designed architecture. For this,  use props to pass data to child components and manage state within components using the useState hook. For more complex state management, consider lifting state up to the nearest common ancestor or using a context.

3.2 Choose a State Management Library

To build React Native app that manage state effectively, use React’s built-in useState and useContext. They are excellent for simple apps. However, as applications grow in complexity, you can switch to libraries like Redux or Zustand.

3.3 Organize State Logic

Organizing state logic separately from UI components keeps your codebase clean and easier to maintain. For Redux, create a dedicated redux directory with actions and reducers. By doing so, you will create React Native app, which is simpler to debug.

3.4 Choose a Navigation Library

React Navigation makes it easy to handle moving between different screens in your app. It’s flexible and helps you manage things like screen transitions and deep linking without extra effort. Use React Navigation for robust and flexible navigation handling. You can install it via npm:

npm install @react-navigation/native
npm install @react-navigation/native-stack

And if you are building your with Expo, choose Expo Router.  It provides a file-based routing system using which you can simply navigation setup. You don’t need to worry about configuration issues, as it integrates seamlessly with Expo. You can rapidly set Navigation. 

Expo Router is perfect for Expo-based projects where ease of use and minimal setup are key. However, if you're working on a non-Expo project or need more flexibility, you might want to explore libraries like React Navigation or Reach Router, which offer more customization options.

3.5 Set Up Navigation

Here’s how you can set up navigation with Expo Router. First, you need to install Expo Router, if you haven't, install the necessary packages.

expo install expo-router

Create the app directory: Expo Router uses the app directory to manage screens and routes. Create a new directory in your project root called app.

Define your screens: Inside the app directory, create your screen components by naming them after the route you want. For example, for a home screen and an about screen:

app/index.js (for the home screen):

import { Text, View } from 'react-native';

export default function HomeScreen() {
  return (
    <View>
      <Text>Home Screen</Text>
    </View>
  );
}

app/about.js (for the about screen):

import { Text, View } from 'react-native';

export default function AboutScreen() {
  return (
    <View>
      <Text>About Screen</Text>
    </View>
  );
}

Add navigation links: To link between these screens, you can use the Link component provided by Expo Router.

Example (inside app/index.js):

import { Link } from 'expo-router';
import { Text, View } from 'react-native';

export default function HomeScreen() {
  return (
    <View>
      <Text>Home Screen</Text>
      <Link href="/about">
        <Text>Go to About Screen</Text>
      </Link>
    </View>
  );
}

Run your app: Now, you can run your app to see the navigation in action.

expo start

Expo Router automatically handles routing based on the file structure in the app directory, so if you want to add more screens, simply create new files and use Link to navigate between them. This method provides a clean and easy-to-use navigation system.

3. 6 Manage Navigation State

Use navigation props to pass parameters between screens and manage navigation state effectively. You can use Expo Router; however, it doesn’t include  state management option. Here’s how you can do it in simple ways.

3.6.1 Set up Folder-based Routing

Expo Router uses a file-based routing system where the structure of your app’s files defines the routes. To use this, create a folder structure inside the app directory, with each folder corresponding to a screen or a route.
app/

  ├── index.js  (Home Screen)

  ├── profile.js (Profile Screen)

3.6.2 Navigation State with Link

To navigate between screens, use the Link component provided by Expo Router. It automatically handles navigation state.

import { Link } from 'expo-router';

const HomeScreen = () => {
  return (
    <View>
      <Text>Welcome to the Home Screen</Text>
      <Link href="/profile">Go to Profile</Link>
    </View>
  );
};

3.6.3 Access Navigation State

To access and manage the navigation state, use hooks like useNavigation and useRoute provided by Expo Router. Example of using useRoute to get route params:

import { useRoute } from 'expo-router';

const ProfileScreen = () => {
  const route = useRoute();
  const { userId } = route.params; // Assuming userId is passed in navigation

  return (
    <View>
      <Text>Profile of User: {userId}</Text>
    </View>
  );
};

3.6.4 Navigate Programmatically

If you need to navigate programmatically, use the useRouter hook to access the router and navigate. Example:

import { useRouter } from 'expo-router';

const GoToProfileButton = () => {
  const router = useRouter();

  const navigateToProfile = () => {
    router.push('/profile'); // Navigate to the Profile screen
  };

  return <Button title="Go to Profile" onPress={navigateToProfile} />;
};

By using Expo Router, you can manage the navigation state more intuitively through file-based routes, making your React Native app easier to navigate and maintain.

4. Develop with Best Practices

There are some guidelines like how to write and test code, 

4.1 Write Clean Code

Clean code is crucial for maintainability and collaboration. Here are some tips:

• Use consistent coding conventions like ESLint or Prettier. 

• Choose descriptive names that convey the purpose of the variable. For instance, instead of var1, use userProfile or fetchUserData.

• While clean code should be self-explanatory, adding comments can clarify complex logic or decisions. This is especially helpful for new team members or when revisiting your code after some time.

4.2 Test Thoroughly

There are so many tools available in React ecosystem for end-to-end testing, among them a few popular tools that you can use for end-to-end testing are:

Detox: This tool is highly favored in the React Native community. Detox allows developers to run tests directly in a simulated or physical environment. It’s known for automating tests effectively and providing good support for both iOS and Android platforms.

Appium: An E2E testing tool, Appium supports both native and hybrid apps. Because it isn't limited to React Native, it's versatile and can be an excellent choice if you're working in a mixed technology environment or plan to reuse tests across different app types.

Maestro: Maestro works well with both iOS and Android apps. It's particularly popular for simplifying test writing.

You can further use testing frameworks like Jest to write unit tests for your components and functions.

4.3 Debug Propely 

With built-in tools, you can easily debug your React Native app. To debug the app, you can follow the below procedures: 

• First, open the Dev Menu

• To open it, shake your device or use keyboard shortcuts: on iOS, press Cmd + D, and on Android emulators, use Cmd + M (macOS) or Ctrl + M (Windows/Linux)

• You can also type adb shell input keyevent 82 in the terminal for Android. 

Keep in mind that the Dev Menu is only available during development and won’t appear in production builds.

React Native DevTools is a main debugging tool. It has an interface for inspecting your app’s JavaScript code, similar to Chrome DevTools. To access it, open the Dev Menu and select “Open DevTools,” or press j in the command line when running npx react-native start.

DevTools, which requires the Hermes engine and either Chrome or Edge, gives you panels for examining React components, profiling performance, and viewing console logs.

You can use LogBox, an in-app tool, to catch warnings and errors. It is useful for catching syntax errors, which will freeze the app until they’re fixed. Non-fatal errors appear as notifications, while fatal errors show up in LogBox and cannot be dismissed until resolved. 

4.4 Optimize Performance

Optimizing performance in React Native can make a noticeable difference in user experience, especially for apps that handle large amounts of data or need to run smoothly on a wide range of devices. Here are some key techniques and tools, including the use of FlashList, to keep your app fast and responsive:

1. Use FlashList for Large Lists, it minimizes lag and optimizes rendering time, making it a great option for feeds, catalogs, or any screen with extensive scrolling.

2. Avoid Inline Functions and UseMemo for Caching, use useCallback or useMemo to memoize functions and values, ensuring that components don’t re-render unless necessary.

3. Use libraries like react-native-fast-image to handle image caching and loading efficiently.

4. Reduce Re-renders with React.memo, wrap it in React.memo to avoid re-renders. 

5. Leverage Lazy Loading and Code Splitting, use React.lazy and Suspense to load components on demand.

6. Minimize JavaScript Thread Usage, offload any heavy operations to native code or background threads if possible.

7. Implement a Custom Animation Driver, for complex animations, consider using libraries like react-native-reanimated. 

By focusing on efficient list rendering with FlashList, reducing unnecessary re-renders, and keeping the JavaScript thread optimized, your React Native app will be able to handle complex workloads smoothly and effectively.

4.5 Leverage Community Resources

The React Native community is vast and filled with resources that can speed up your development process:

• Utilize open-source libraries from platforms like GitHub to save time and effort. 

• Look for development tools and plugins that can enhance your workflow. Tools like Expo can streamline your development process.

5. Deploy Your App

Once your app is ready for public release, you'll need to submit it to app stores like the Apple App Store and Google Play Store. Before submitting your app, you need to be aware of each platform’s guidelines that cover aspects like design, functionality, and content. 

You will need to write a persuasive description, create a visually appealing app icon, and some snapshots of your app. Ensure that you have had rigorous testing, as the app may be rejected during the review process. 

Furthermore, there is a tool  – Expo’s OTA updates, that you can use to deliver updates directly to users’ devices. If you are not using Expo, you can use CodePush for the same.

Conclusion

React Native has emerged as the most popular framework for cross-platform mobile app development, offering developers a streamlined approach to building apps for multiple platforms. It provides a rich ecosystem of libraries and features that significantly accelerate development time.

Given the rapid growth of the mobile app market, there's a wealth of opportunities in mobile app development. If you're considering venturing into this field, React Native presents an excellent starting point.