Rami Pinto Prieto

Senior Specialist, Industry Solutions

> If you haven’t yet followed our guide on how to [build an inventory management system using MongoDB Atlas](https://www.mongodb.com/developer/products/atlas/build-inventory-management-system-using-mongodb-atlas/), we strongly advise doing so now. This article builds on top of the previous one to bring powerful new capabilities for real-time sync, conflict resolution, and disconnection tolerance!

In the relentless world of retail logistics, where products are always on the move, effective inventory management is crucial. Fast-moving operations can’t afford to pause when technical systems go offline. That's why it's essential for inventory management processes to remain functional, even without connectivity. To address this challenge, supply chains turn to Atlas Edge Server to enable offline inventory management in a reliable and cost-effective way. In this guide, we will demonstrate how you can easily incorporate Edge Server into your existing solution.

![Multi-store offline inventory architecture][1]

In the [first part of our tutorial series](https://www.mongodb.com/developer/products/atlas/build-inventory-management-system-using-mongodb-atlas/), we explored how MongoDB Atlas enables event-driven architectures to [enhance inventory management with real-time data strategies](https://www.mongodb.com/blog/post/how-enhance-inventory-management-real-time-data-strategies). Now, we are taking that same architecture a step further to ensure our store operations run seamlessly even in the face of connectivity issues. Our multi-store setup remains the same: We’ll have three users — two store managers and one area manager — overviewing the inventory of their stores and areas respectively. We'll deploy identical systems in both individual stores and the public cloud to serve the out-of-store staff. The only distinction will be that the store apps will be linked to Edge Server, whereas the area manager's app will remain connected to MongoDB Atlas. Just like that, our stores will be able to handle client checkouts, issue replenishment orders, and access the product catalog with no interruptions and minimal latency. This is [how Atlas Edge Server bridges the gap between connected retail stores and the cloud](https://www.mongodb.com/blog/post/how-atlas-edge-server-bridges-gap-between-connected-retail-store-cloud).

Without further ado, let's dive in and get started!

## Prerequisites

For this next phase, we'll need to ensure we have all the prerequisites from Part 1 in place, as well as some additional requirements related to integrating Edge Server. Here are the extra tools you'll need:

- **Docker** (version 24 or higher): Docker allows us to package our application into containers, making it easy to deploy and manage across different environments. Since Edge Server is a containerized product, Docker is essential to run it. You can choose to [install Docker Engine](https://docs.docker.com/engine/install/) alone if you're using one of the supported platforms or as part of the [Docker Desktop](https://docs.docker.com/get-docker/) package for other platforms.
- **Docker Compose** (version 2.24 or higher): Docker Compose is a tool for defining and running multi-container Docker applications. The Edge Server package deploys a group of containers that need to be orchestrated effectively. If you have installed Docker Desktop in the previous step, Docker Compose will be available by default. For Linux users, you can install Docker Compose manually from this page: [Install the Docker Compose](https://docs.docker.com/compose/install/linux/) plugin.
- **edgectl** (version 0.23.2 or higher): edgectl is the CLI tool for Edge Server, allowing you to manage and interact with Edge Server instances. To install this tool, you can visit the official documentation on how to [configure Edge Server](https://www.mongodb.com/docs/atlas/app-services/edge-server/configure/) or simply run the following command in your terminal: `curl https://services.cloud.mongodb.com/edge/install.sh | bash`.

With these additional tools in place, we'll be ready to take our inventory management system to the next level.

## A quick recap

Alright, let's do a quick recap of what we should have in place already:

- **Sample database**: We created a sample database with a variety of collections, each serving a specific purpose in our inventory management system. From tracking products and transactions to managing user roles, our database laid the groundwork for a single view of inventory.
- **App Services back end**: Leveraging Atlas App Services, we configured our app back end with triggers, functions, HTTPS endpoints, and the Data API. This setup enabled seamless communication between our application and the database, facilitating real-time responses to events.
- **Search Indexes**: We enhanced our system's search capabilities by setting up Search Indexes. This allows for efficient full-text search and filtering, improving the user experience and query performance.
- **Atlas Charts**: We integrated Atlas Charts to visualize product information and analytics through intuitive dashboards. With visually appealing insights, we can make informed decisions and optimize our inventory management strategy.

![Inventory management system architecture using MongoDB Atlas and Next.js][2]

Building on our previous setup, let's envision a typical retail scenario where our inventory management application will truly shine with the incorporation of Edge Server.

![Offline inventory architecture normal scenario][3]

Suppose the area manager needs to update the product catalog. The data seamlessly flows to MongoDB Atlas, where it is then transmitted to Edge Server. Once received, Edge Server stores the update locally and makes it available for retrieval by endpoint devices. This ensures that any changes made centrally are quickly propagated to all connected stores, maintaining consistency across the board.

![Offline inventory architecture disconnection scenario][4]

Now, let's consider a situation where a remote store experiences a temporary disconnection from the cloud. Despite this, the data stored on Edge Server remains accessible. Store staff can continue with essential tasks like sales, catalog checks, and placing orders, as Edge Server diligently queues any updates. Meanwhile, changes made by the area manager are queued in the cloud and await synchronization with the remote store once it's back online. This uninterrupted flow of operations ensures business continuity even during connectivity disruptions.

![Offline inventory architecture reconnection scenario][5]

Finally, when the remote store reconnects to the cloud, the queued updates are exchanged, ensuring synchronization between the local and cloud databases. Any pending operations are applied, and both systems converge to the same final state. This seamless reintegration process guarantees that all stores operate with the latest data, irrespective of connectivity challenges.

To achieve this, we’ll need to make a couple of adjustments to our existing setup.

## MongoDB Atlas configuration

### Flag store managers as edge users

Flagging store managers as edge users will allow our app to switch the database connection from Atlas to Edge Server. This is useful for the guide purposes, as it will simplify the setup not requiring extra app deployments to use different users.

1. Go to your Atlas dashboard, access the Data Services page, locate your cluster, and click on "Browse Collections."
2. Find the "users" collection and open it. Users are categorized based on whether they are expected to connect to an Edge Server instance (`type: “edge”`) or directly to Atlas (`type: “altas”`). Look for the attribute `type`, which is currently set as "atlas" for all users. Double-click on it, change the value to "edge," and click the "Update" button to confirm. After applying the changes, your users in the collection should reflect this update.

![Users collection view in MongoDB Atlas][6]

Let's explore how this flag impacts our application's code. Consider the simplified version of the `getServerSideProps` function on our main products page:

```javascript
export async function getServerSideProps({ query }) {
  try {
    const dbName = process.env.MONGODB_DATABASE_NAME;
    const edge = (query.edge === 'true');
	
    // Use a different connection based on the edge flag
    const client = edge ? await getEdgeClientPromise() : await getClientPromise();
    
    //Connect to the database and fetch the products
    const db = client.db(dbName);
    const products = await db.collection("products").find({}).toArray();

    return { props: { products: JSON.parse(JSON.stringify(products)) }};
  } catch (e) {
    console.error(e);
    return { props: { products: [] }};
  }
}
```

This function dynamically determines whether to connect to the Edge Server or Atlas based on the user's type. For a more detailed version of this function, including controls for filter facets and user role distinctions, refer to the app/pages/products/index.js file in your cloned repository.

### App Services configuration

In this section, we'll ensure that Edge Server is properly configured and ready to run. While most of the setup should have been covered in Part 1 of the tutorial series, we'll review and verify the existing configurations and add any additional steps as needed.

Here are the steps to ensure Edge Server is properly configured and ready to run:

1. Go to the App Services tab in Atlas, located next to the Data Services tab. Find the app created in Part 1 of the tutorial series and click on it.
2. First, we’ll verify that Device Sync has been successfully enabled. Access the Device Sync tab in the left-side menu and ensure that you see the "enabled" tag next to the page title.
3. To check we have the proper data access permissions in place, head to the Rules tab in the left-side menu. Locate your database and click on each collection to confirm the following permissions:
    - In the "locations," "products_area_view," and "users" collections, you should see a "readAll" permission.
    - In the "products" and "transactions" collections, you should see a "readAndWriteAll" permission.
4. Next, open the Authentication tab and verify that both the anonymous and API Key providers are enabled.
5. Lastly, we’ll need to get our One-time Registration Token:
    - Go to the Device & Edge Sync tab and click on "Deploy Edge Server."
    - On the next screen, provide a name for your Edge Server services and select the database created in Part 1 as the datasource.
    - Confirm by clicking "Create service."
    - A token will be generated; ensure you copy it and store it securely, as it won't be available again.

![App services device & edge sync view][8]

With these configurations in place, your Edge Server instance is now ready to be configured and run effectively.

## Configure Edge Server

As we have seen, Edge Server is a "local" server that sits between your client devices and MongoDB Atlas App Services. For most use cases, you'll provision hardware on-premises to host Edge Server. But for the purpose of this guide, you may host it on your own device for convenience. To learn more about hosting options, please visit our [Edge Server Host Requirements](https://www.mongodb.com/docs/atlas/app-services/edge-server/configure/#edge-server-host-requirements) documentation.

Follow these instructions to set up and run Edge Server on your own device:

We will configure Edge Server using the command-line tool edgectl. By default, this tool will be installed at `.mongodb-edge` in your home directory. You can reference the entire path to use this tool, `~/.mongodb-edge/bin/edgectl`, or simply add it to your `PATH` by running the command below: 

```
export PATH="~/.mongodb-edge/bin/:$PATH"
```

The next command will generate a docker-compose file in your current directory with all the necessary steps to deploy and manage your Edge Server instance. Replace `<your-app-id>` with the value obtained in the first part of this tutorial series, and `<your-auth-secret>` with the token generated in the previous section.

```
edgectl init --platform compose --app-id <your-app-id> --registration-token <your-registration-token> --insecure-disable-auth
```

> Note: To learn more about each of the config flags, visit our documentation on how to [install and configure Edge Server](https://www.mongodb.com/docs/atlas/app-services/edge-server/configure/#install-and-configure-the-edge-server).

This application is able to simulate offline scenarios by setting the edge server connectivity off. In order to enable this feature in Edge Server, run the command below.

```
edgectl offline-demo setup
```

![Action to simulate offline scenarios][9]

Lastly, to start the server, from the edge_server directory, run:

```
edgectl start
```

Check the status by running `edgectl status`. You should see the value `"cloud_connected": true` indicating that Edge Server is connected to MongoDB Atlas.

> Important: Once you are done with the tutorial, remember to stop the server by running `edgectl stop` in the edge_server directory.

## Frontend configuration

### Update your environment variables

We’ll need to add an extra environment variable to specify the address of the server hosting your Edge Server instance. In this case, it will be just `localhost` because it will run on our own device, but you can definitely try different deployment options! 

Navigate to the `app` directory. If you are currently in the `edge_server` one, you can run the command below:

```
cd ../app
```

Open the `.env.local` file with your preferred text editor or IDE, and add a new line for the environment variable `EDGE_SERVER_HOST`. 

```
EDGE_SERVER_HOST=localhost
```

We should have nine environment variables in total by now: `MONGODB_URI`, `MONGODB_DATABASE_NAME` , `REALM_APP_ID`, `APP_SERVICES_URI`, `API_KEY`, `CHARTS_EMBED_SDK_BASEURL`, `DASHBOARD_ID_PRODUCT`, `DASHBOARD_ID_GENERAL`, and `EDGE_SERVER_HOST`.

As usual, please remember to save the updated file.

### Run locally

We are ready to launch our new inventory management system! Execute the following commands to run your app locally: 

```
npm ci
npm run dev
```

Your app should be up and running on http://localhost:3000. Hurray!

## Wrapping up


Congratulations! Your inventory management app is now equipped with the power of Atlas Edge Server, ensuring seamless operation even in challenging connectivity scenarios. Here's a quick rundown of what you've achieved in this tutorial:

- **Enhanced inventory management:** Atlas Edge Server enables hybrid architectures without sacrificing real-time monitoring of stock levels, ensuring precise inventory control and timely restocking.
- **Seamless operational workflows:** Edge computing ensures essential store tools remain operational during connectivity hiccups.
- **Reduced complexity:** By integrating Atlas Edge Server into existing architectures, retailers can offload operational burdens and focus on delivering differentiated experiences to delight their customers.

But wait, there's more to explore! Dive deeper into MongoDB's capabilities and discover how it's revolutionizing the retail industry:

- [MongoDB for Retail Innovation](https://www.mongodb.com/industries/retail)
- [Atlas Edge Server](https://www.mongodb.com/products/platform/atlas-edge-server)
- [How Atlas Edge Server Bridges the Gap Between Connected Retail Stores and the Cloud](https://www.mongodb.com/blog/post/how-atlas-edge-server-bridges-gap-between-connected-retail-store-cloud)
- [Grainger Innovates at the Edge With MongoDB Atlas Device Sync and Machine Learning](https://www.mongodb.com/customers/grainger)


  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt8ea62e50ad7e7a88/66293b9985518c840a558497/1.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt43b8b288aa9fe608/66293bb6cac8480a1228e08b/2.png
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltf2995665e6146367/66293bccb054417d969a04b5/3.png
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt5fad48387c6d5355/66293bdb33301d293a892dd1/4.png
  [5]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt480ffa6b4b77dbc0/66293bed33301d8bcb892dd5/5.png
  [6]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltc5f671f8c40b9e2e/66293c0458ce881776c309ed/6.png
  [7]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltd31d0f728d5ec83c/66293c16b8b5ce162edc25d0/7.png
  [8]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt3c061edca6899a69/66293c2cb0ec77e21cd6e8e4/8.png
  [9]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt2d7fd9a68a6fa499/66293c4281c884eb36380366/9.gif

Learn to bring capabilities for real-time sync, conflict resolution, and disconnection tolerance to your inventory management system using MongoDB Atlas!

No Connectivity? No Problem! Enable Offline Inventory With Atlas Edge Server

This tutorial takes you through building a web app capable of navigating your product catalog, receiving alerts, and automating restock workflows.

Build an Inventory Management System Using MongoDB Atlas

MongoDB

Jeff Needham

Principal of Industry Solutions 

Luca Napoli

Industry Solutions Consultant

This tutorial walks you through the refactoring of the OMG Party Role data model, a widely used insurance standard. With the help of MongoDB Relational Migrator, you’ll be able to refactor your relational tables into MongoDB collections and reap all the document model benefits.

Rami Pinto Prieto

Content by Rami Pinto Prieto

No Connectivity? No Problem! Enable Offline Inventory With Atlas Edge Server

Build an Inventory Management System Using MongoDB Atlas

Modernize Your Insurance Data Models With MongoDB Relational Migrator