The Problems With Building Apps for E-Commerce Platforms and Why We Built Common Ninja

Let's start with the bottom line:

Building apps for e-commerce platforms is hard.

Background

E-Commerce platforms (such as Shopify, BigCommerce, Wix, WooCommerce, etc.) are great for people who want to build and manage shops online. They provide the best tools for shop owners to manage inventory, customize their storefront, and start making revenues from online orders.

But at the end, these platforms are limited, and this is why they allow developers to leverage their APIs and data to develop apps on top them.

These apps are being used by merchants and their customers and they are quite varied. From storefront widgets that increase conversions and enhance the user experience, to apps that collects data to improve inventory management, to social proof apps, and easy drop shipping.

E-Commerce apps are widely used by online merchants, and become very popular. How popular? Shopify says that in 2020 the average merchant installed 6 apps on his store, and that developer partners earned $233M in 2020 alone.

The thing is...

If you ask any developer who had an experience with building apps for e-commerce platforms "How was your experience?" you'll get the same answer: "It was a hell of a nightmare".

The Problems With E-Commerce Platforms For Developers

When you first start building an app you're entering a world of pain.

It starts with the documentation. In order to build an app you'll need to read. A lot. And while some platforms did a nice job with onboarding developers to their platform and documenting everything, others don't.

Once you find your way in the endless docs, and understand the different types of apps each platform allows you to build, the next thing will be to handle authentication.

Surprisingly, although most of the platforms are using OAuth, each one of them implemented the authentication flow differently so you'll need to learn exactly how it works on each platform separately while using tunnels (and in some cases to debug the code in production because you have to contact the platforms in order to change the auth endpoints).

I hope you're still here because there's more!

The next thing would be APIs. Let's take the Product resource as an example.

In Shopify a product object looks like that:

interface IShopifyProduct {
  id?: string;
  title?: string;
  body_html?: string;
  vendor?: string;
  product_type?: string;
  created_at?: string;
  updated_at?: string;
  handle?: string;
  variants?: {
    id?: string;
    product_id?: string;
    price?: string; // no unit supported in api
    weight?: number;
    weight_unit?: string;
  }[]
  images?: IShopifyProductImage[];
  status?: 'active' | 'archived' | 'draft';
  tags?: string;
}

interface IShopifyProductImage {
  product_id?: number;
  id?: number;
  title?: string;
  position?: number;
  created_at?: string;
  updated_at?: string;
  alt?: string;
  weight?: number;
  weight_unit?: 'kg' | 'lb';
  price?: number | string;
  src?: string;
  variant_ids?: string[];
  admin_graphql_api_id?: string;
}

And in BigCommerce like this:

interface IBigCommerceProduct {
  id?: number;
  name?: string;
  description?: string;
  date_created?: string;
  date_modified?: string;
  custom_url?: {
    url?: string;
  };
  type?: 'physical' | 'digital';
  weight?: number;
  price?: number;
  primary_image?: IBigCommerceProductImage;
  images?: IBigCommerceProductImage[];
}

interface IBigCommerceProductImage {
  image_file?: string;
  is_thumbnail?: boolean;
  product_id?: number;
  id?: number;
  description?: string;
  sort_order?: number;
  date_modified?: string;
  url_standard?: string;
  url_thumbnail?: string;
  url_tiny?: string;
}

While in Wix it's:

interface IWixProduct {
  id: string;
  name: string;
  slug: string;
  visible: boolean;
  weight: number;
  description: string;
  sku: string;
  productType: 'physical';
  priceData?: {
    currency?: string;
    price: number;
  };
  media?: IWixProductMedia;
  lastUpdated?: string;
}

There's no standardization, each platform sees things differently which is ok, unless you want to build an app that supports multiple platforms.

And finally - monetization.

If you're building an app, either for yourself or for a company you're working for, your end goal is obviously to see revenues out of it. However, while some platforms like Shopify and Wix are giving you some tools to monetize your app in different business models, all of the other platforms don't. Which means, that in addition to everything else you'll need to integrate payment solutions as well, and develop these integrations yourself.

Common Ninja: A New Era Of E-Commerce Apps Development

We know these problems very closely, since in the past 10 years we developed dozen of apps for website building and e-commerce platforms.

During these years we developed a lot of tools that helped us to decrease the development time of e-commerce platforms apps in 80%, which led us to establish Common Ninja and offer these tools to any developer out there 🎉

Common Ninja is a platform for building & monetizing e-commerce apps.

Our main offering is "One API to rule them all".

You'll work with a single API for consuming e-commerce resources such as products, orders, customers, etc. regardless the platform your user/merchant is using. You always know what you get, and if an e-commerce platform is changing their API, we take care of it behind the scenes so you won't have to.

In addition, with Common Ninja you'll be able to monetize your app flawlessly, create subscriptions based plans, and connect your app to popular payment providers like Stripe and PayPal.

Too good to be true? Probably. But this is us, and that's what we do 🙂

Want to learn more? go here:
https://www.commoninja.com/developers

If you have any feedback, question or comment, we're here.