Moving from Shopify Plus to Microservices-Based Commerce
Tags: microservices, webdev
Published: 2021-05-13 22:01:27

If you’re selling products online, there’s a good chance you’re using a one-size-fits-all platform. These platforms offer many advantages but they also have limitations. If you want to move beyond these limitations, [microservices](https://resources.fabric.inc/blog/answers/ecommerce-microservices-architecture) can help.

Shopify Plus is a one-size-fits-all platform that allows you to use headless systems while retaining most of its features. So if you already have a Shopify Plus setup, you can keep the frontend and migrate the backend to a microservices-based alternative for more flexibility.

In this post, we'll explain why businesses are moving away from monolithic e-commerce platforms like Shopify Plus and how they are doing it from a high level.

**Note:** We've written before about migrating away from [classic e-commerce monoliths](https://resources.fabric.inc/blog/answers/enterprise-ecommerce-platforms) like [Salesforce Demandware](https://resources.fabric.inc/blog/salesforce-commerce-to-microservices). As you'll see, many of the same concepts and migration practices apply to modern monoliths like Shopify Plus.

Why Microservices?
------------------

Shopify is a fantastic system in many ways, but if you use it exclusively you have to accept its limitations. Moving all or part of your system away from it can avoid these problems. Let’s look at some of the areas microservices can improve.

### Security

*   Shopify has [been in the news](https://techcrunch.com/2020/09/23/shopify-data-merchant-breach/) regarding data theft before. Managing your services means you’re free to address those concerns and implement additional security.
*   Its fraud protections aren’t as comprehensive as some services, so moving to a different payment system that matches your requirements can give you and your customers peace of mind.
*   Working with APIs means you can control the data flow in and out of your backend. It also means you can develop it incrementally while building on what you already have. That means you don’t have to reinvent the wheel when you want to offer something new on the frontend.

### Technical Limitations

*   One issue with Shopify Plus is its [lack of multi-store architecture](https://paulnrogers.com/shopify-plus-international-multi-store/), though this feature has been promised in the future and some plugins may help with it. If you can’t wait, you can build a backend that can handle data across all your outlets.
*   Shopify Plus's SEO approach is good but hard to modify. Using a custom frontend can allow you to change the URL structure, the robots.txt file, and give you better control over your subdomains.
*   It’s a similar situation with Shopify’s checkout. It’s hard to customize, leaving you with a fixed approach. What’s there isn’t bad; it’s just that you can’t deviate from it significantly or add specific features easily.
*   Shopify Plus can also slow down as you add features; its [plugins don’t have to be certified](https://weareuv.com/shopify-vs-salesforce-commerce-cloud-which-one-should-i-choose/). Handling services independently means you can ensure they continue to perform at the level you require.

### Flexibility

*   Shopify allows you to get up and running quickly, but you’re tied into the way it does things. With microservices, you can take a [modular approach](https://resources.fabric.inc/blog/glossary/modular-commerce), get the essentials in place, and add whatever you need on top.
*   Shopify apps aren’t always geared to work well internationally and can cost a lot if you have multiple local versions of your store. Data for multiple stores is also tricky to combine.
*   Shopify payments can have restrictions for products, as well as countries and currencies. You need a local business and bank account in each territory you have a store. That makes changing and expanding difficult.
*   With microservices, you can add an API query doing whatever it is you need—you aren’t limited to what Shopify offers. If you need to support a new feature, you can do that.

Replacing Shopify Plus
----------------------

You can take advantage of the modularity of microservices to move from Shopify bit by bit. Identify what you can benefit most from replacing and build it. If you do that repeatedly, you can move away from Shopify step by step, improving your service with minimal disruption.

### Step 1: Decide Where to Start the Migration

Let’s look at some of Shopify Plus’s services and decide what to implement using microservices.

#### Product Information Management (PIM)

Your Shopify installation will include lots of product-specific data. Moving this to a separate backend, with an API letting you retrieve, modify, and create new products, is a great place to start.

Decoupling this data from Shopify means you can use it on any of the new channels you create. It gives you complete control over what’s shared, and the formatting and structure can be defined however you like.

Fabric has a [prebuilt PIM system](https://fabric.inc/pim) that will help you make the transition quickly and easily and offers you plenty of flexibility. As well as helping you get set up, Fabric can also help with data migration.

#### Order Management System (OMS)

Your order management system includes your user’s shopping cart as well as payments. You have to smoothly pass the data on to your payment handler and delivery setup while allowing users to track and potentially cancel the whole process. There’s a lot involved, and everything needs to run like clockwork.

Taking control of this area means you can evolve it over time and perfect everything, adding features for the various frontend services you want to use while ensuring the core functionality is rock-solid.

Fabric can help with this, too. Its [OMS](https://fabric.inc/oms) promises a friction-free experience that can drive customer satisfaction and make life easier for everyone involved in your order and delivery chain.

#### Other Supporting Services

Shopify Plus offers a whole suite of features and services. Some of these will matter to you more than others—priorities differ from business to business. When picking a feature to include, you should consider what you’d like to make available to channels other than Shopify and which areas have the most scope for improvement.

These might include store management, customer personalization, or analytics. Take a look at the features [Fabric offers](https://fabric.inc/products) to see what it can do for you in those areas.

### Step 2: Build a Middle Layer

To integrate your new services with your Shopify installation, you can set up an [API gateway](https://www.shopify.com/partners/blog/shopify-webhooks-how-to-prep-your-app-this-black-friday-cyber-monday). That will let you reroute requests to your new backend.

You could also adopt a [service mesh](https://resources.fabric.inc/blog/ecommerce-service-mesh) model, which handles communication between your application components and lets you manage data flow between your existing application and external microservices.

![E-commerce microservice architecture with service mesh](https://resources.fabric.inc/hs-fs/hubfs/E-commerce%20microservice%20architecture%20with%20service%20mesh.png?width=886&name=E-commerce%20microservice%20architecture%20with%20service%20mesh.png)

With a new layer in place, you can look at replacing services one by one, thoroughly testing at each stage, and ensuring the new process is fully integrated before moving on to the next.

### Step 3: Migrate Data from Shopify Plus to Microservices

To move data from your old system, you can export it to a CSV file, then use JavaScript to shift it across to your new microservice. You can do this as you go, create a service, copy your data into it, and then adjust your API gateway to handle future requests from Shopify.

#### Exporting Data from Shopify Plus

Shopify Plus has a simple export system, letting you easily create a CSV file. Its [documentation explains](https://help.shopify.com/en/manual/shopify-admin/duplicate-store) how to do this for a product, customer, and order data, among other things. You can find an [example file here](https://help.shopify.com/en/manual/products/import-export/using-csv).

Shopify product data includes the following fields:

| Required | Required but can be blank | Optional |
| --- | --- | --- |
| Handle | Body | SEO Title |
| Title | Vendor | SEO Description |
| Published | Type | Google shopping metafields |
| Status | Tags | Cost per item |
| | Image Src | |
| | Image Position | |
| | Image Alt Text | |
| | Gift Card | |

There are more fields for products that have additional options and variants. [Consult the documentation for details](https://help.shopify.com/en/manual/products/import-export/using-csv).

Your new system won’t have to use the same fields, so you can pick and choose which are relevant to you and which, if any, are required in your system. That kind of flexibility is one of the advantages of working with microservices. You can have a compact, faster system or one that contains whatever extra information you need.

#### Importing Data into Microservices

You can use JavaScript to transfer your data into your new system. Here’s an example showing how to import data using the latest version of [Amazon SQS](https://aws.amazon.com/sqs/). You can find more details in [Amazon’s documentation](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sqs-examples-send-receive-messages.html).

```javascript
 
const { SQSClient, SendMessageCommand } = require("@aws-sdk/client-sqs");
 
const REGION = "us-east-1"; //or whatever your region is
 
const params = {
 
DelaySeconds: 10,
  MessageAttributes: {
	Title: {
  	DataType: "String",
  	StringValue: "Sneakers",
	},
	Vendor: {
  	DataType: "String",
  	StringValue: "Comfy Sneakers Inc",
	},
	InventoryQty: {
  	DataType: "Number",
  	StringValue: "146",
	},
	Value: {
  	DataType: "Number",
  	StringValue: "79.99",
	},
  },
  MessageBody:
	"Product Data.",
 
  QueueUrl: "SQS_QUEUE_URL", //replace this with your queue URL
 
}
 
const sqs = new SQSClient({ region: REGION});
 
const run = async () => {
  try {
	const data = await sqs.send(new SendMessageCommand(params));
	console.log("Success, product sent. MessageID:", data.MessageId);
  } catch (err) {
	console.log("Error", err);
  }
};
run();
 
```

### Step 4: Test and Repeat

As you expand your microservices and move functionality away from Shopify, it’s essential to test thoroughly. This should be done at every stage. You need to have a rigorous testing system to ensure everything is still working smoothly, including the area being moved and everything else.

#### Advantages of the Iterative Approach

Taking a section by section approach means you can focus on a particular service and know where to look should any problems arise. That makes issues easier to fix and the overall adjustment smoother.

In addition to finding errors, it’s helpful to have metrics that measure the speed of transactions. If you can connect these to sales and customer retention, all the better. 

Conclusion
----------

Shopify Plus is an excellent platform with much to like about it, but the world is moving away from one-size-fits-all software toward more flexible, customized solutions.

Building services yourself is very achievable, but there is plenty of support available so you don’t have to go it alone entirely. An existing solution can save you time and money, and, as these services mature, the argument for that route gets stronger.

Consider taking advantage of prebuilt or customized microservices with [Fabric](http://fabric.inc/) to quickly build a system that offers adaptability for new challenges and opportunities based on solid, reusable foundations.