Notice something different? Meet the new Solidus brand!

Use Cases

Use cases

Product

Developers

Resources

Big player with big needs? See what Solidus can do for you.

Enterprise

Solutions

The foundation to stand up. The flexibility to stand out.

Features

Don’t reinvent the wheel—use our built-in integrations.

Integrations

Pricing plans designed to accommodate your growth.

Pricing

Documentation

Policies

Insights and announcements from the Solidus team.

Blog

Need a bit of help? Engage our trusted partners!

Partners

Join us if you want to chat—we're a friendly bunch!

Community

## Introducing SolidusConf Speaker Jared Norman


We’re proud to announce that Jared Norman will be joining us as a speaker for **SolidusConf 2020**.

Jared Norman is an experienced Rubyist, bad hockey player, devoted metalhead, and the founder of [Super Good Software](https://supergood.software/), an agency specializing in Solidus/Spree, e-commerce, and Ruby on Rails.


### The Agile Fluency Model and eCommerce

Many Agile organizations are just going through the motions of their chosen process. Jared will walk us through how the Agile Fluency Model applies to eCommerce businesses and how they can use it to discover where they should focus to reap the real benefits of Agile methodologies.

### [See Jared speak at SolidusConf 2020](https://www.youtube.com/watch?v=9M0h2D4IvkE)

We’re proud to announce that Jared Norman will be joining us as a presenter for SolidusConf 2020.

SolidusConf 2020 Speaker Jared Norman

_This post was originally posted on the [Nebulab](https://nebulab.com/) website
[here](https://nebulab.com/blog/solidus-stripe/)._

[Strong Customer Authentication][SCA] (SCA) is a relatively new security
requirement that came in into force in Europe during September 2019.
In order to comply with the law, a store located in Europe must now accept
payments only through an SCA-ready payment method.

[Stripe][stripe], one of the major players in the online payment business, has
been offering a set of [modern API][stripe-api] that comply with these
requirements for a while and these API are now available also to Solidus' stores
via the gem [Solidus Stripe][solidus-stripe].

Currently, Solidus Stripe supports _Elements_, _Payment Intents_, and the _payment
request_ button API; let's briefly discuss the features offered by each of them.

### Stripe Elements

Elements was the first API provided with the third version (V3) of Stripe JS
library that got implemented in the gem.
Elements allows stores to build their payment pages by using pre-defined HTML
elements packed with JS functionality for a secure and easy payment flow:
everything is handled via javascript in the frontend without any need to
communicate with the store backend.

If you don't need SCA, this is by far the simplest and effective solution made
available by the gem: setup is very easy and your store will be ready to accept
credit card payments in a jiffy.

### Stripe Payment Intents

The Payment Intents API is based on Elements, so it maintains the very same
checkout UX and the ease of use when it comes to creating HTML elements, but
it includes the new SCA features that make it much more complex to implement in
regads to interactions with Stripe servers and the app backend:

> this API tracks a payment, from initial creation through the entire checkout
> process, and triggers additional authentication steps when required.

The good news is that the complexity has already been packed inside the
code of the gem, so you can relax and concentrate only on the setup procedure
described in the README.

Still, you may be interested in a general overview of what happens under the
hood when a __3D-Secure__ verification is required. The video shows the payment
process in the browser, a description follows below:

![](https://cdn.sanity.io/images/9g5nd6b4/production/18354dcae1d75d0d7db49ed24298bd0f0e208959-1920x1080.gif?fit=clip&q=40)

1. the Stripe Elements markup is added to the page by creating the card number,
card expire date and card CVC inputs;
2. after the customer enters the payment data and clicks the button, a new
payment method is created on Stripe servers for the given credit card number;
3. some data is added to the HTML form elements that will be used later at
submission time;
4. a JS asynchronous request sends the payment method token to the backend in
order to create a Payment Intents object that, depending on the credit card
type may require the customer to pass the additional SCA verification. The
payment intent has automatic confirmation method but requires manual capture and
can be used later for off session usage (in other words, the customer will be able
to reuse the card that they just entered in the system);
5. the frontend receives from the backend the payment intent client secret
token to be used for the 3D-Secure verification;
6. a 3D-Secure modal completely managed by Stripe pops up in the browser;
7. after successful code verification with the Stripe API, the store backend
tries to create the payment on the DB by using all the data provided by
the  frontend, including the customer address, credit card information and the
Payment Intent ID;
8. if all goes well, the frontend finalizes the payment and completes the form
submission, so Solidus can resume the usual checkout flow by taking the customer
to the last checkout step (confirmation).

You can take a look at the gem source code, especially the javascript part, if
you are interested in getting a deeper understanding of this process.

Be aware of an important _caveat_: the initial Payment Intents charge is created
_uncaptured_ on the payment step; it cannot be captured at that time, otherwise if
the customer leaves the checkout before confirming the purchase, it would not
be possible to revert the charge.
For this reason, capture must happen later in the Solidus backend, after the order
is finalized.

### Payment Request Button

The payment request button is based on Payment Intents and the official W3C
[payment request][payment-request] API. Just like Payment Intents, it's
SCA-ready so it can be safely used also on a European eCommerce.

Instead of leveraging the usual HTML elements, the payment is made in a
native environment specific for each browser.
This payment API is currently the only one from Stripe that supports
__Apple Pay__ and __Google Pay__.

The payment request button can be mounted directly on the cart page, allowing
customers to entirely skip the usual Solidus checkout process. This makes the
guest checkout easier, faster and more convenient, increasing conversions.

The most notable requirement for the button to work is that the store must
be on HTTPS, but setting up Apple Pay requires the extra step of creating a
verification file specific for the store domain and make it available at a
specific URL. Of course, more details can be found on the gem README and on
Stripe documentation.

Here's a video demonstrating the guest checkout with the payment button on the
cart page:

![](https://cdn.sanity.io/images/9g5nd6b4/production/c42dbdaaaf25507a758e6960ceceebe00e812a2d-1920x1080.gif?fit=clip&q=40)

When the customer clicks the button, the browser dialog window pops up
requesting them to choose the shipping address among the ones saved in the
browser, or enter a new one. After that, all the available shipping methods
with their costs are retrieved from the backend and the customer can pick their
preference.

The customer must have at least one credit card registered in their
browser, failing that the button will not show. If more than one card exists,
the customer will be able to choose among all of them.

![](https://cdn.sanity.io/images/9g5nd6b4/production/8fcba37be1986f990d9fcb6fcacd134e2ca10b24-1800x1724.png?fit=clip&q=60)

### Customizations

Customization is done by following the standard Rails/Solidus procedures when
it comes to ruby code (`Module#prepend` and [Deface](deface) are your friends)
while the JS can be customized easily by overriding the existing payment
method prototypes.

One frequent customization may consist in overriding the default locale
for Stripe Elements. If you want to switch from English to the Spanish
language, you can simply redefine the method `elementsBaseOptions` on the
prototype of the constructor `SolidusStripe.Payment` :

```js
SolidusStripe.Payment.prototype.elementsBaseOptions = function () {
  return {
    locale: 'es'
  };
```

Some level of visual customization can be achieved directly with CSS, but
sometimes, when using Elements and Payment Intents, your best option may
be to override the method `baseStyle` on `SolidusStripe.Elements.prototype`.


Enough talk, I hope this post helped in presenting all the possible
payment flows enabled by Solidus Stripe, it's now your turn to pick the
one more suitable for your store... happy coding!

[SCA]: https://en.wikipedia.org/wiki/Strong_customer_authentication
[stripe]: https://stripe.com/
[stripe-api]: https://stripe.com/docs/js
[solidus-stripe]: https://github.com/solidusio/solidus_stripe
[payment-request]: https://www.w3.org/TR/payment-request/
[deface]: https://github.com/spree/deface

Strong Customer Authentication (SCA) is a relatively new security
requirement that came into force in Europe during September 2019.

SCA payments with Solidus Stripe gem

## It’s time for SolidusConf 2020!

### Join us to discuss the past, present, and future of eCommerce
We’re proud to announce that SolidusConf 2020 will be a 100% completely digital experience held between September 23rd through 25th. In addition to bringing the excellent Solidus community together again, we’re also putting together an amazing list of speakers, and 3 unique workshops that you won’t want to miss. Plus, every attendee will receive a swag package in the mail, filled with Solidus-themed goodies. It’s going to be an exciting 3 days, and we can’t wait to see you there!



### Get Your Ticket to SolidusConf 2020
###### Learn, network, and share with the Solidus community
Ticket sales for SolidusConf 2020 are now OPEN. [You can find tickets here](https://opencollective.com/solidus/events/solidusconf-2020-c8147b09) - be sure to pick them up quickly to secure your spot! If you’re a student, reach out to [conf@solidus.io](mailto:conf@solidus.io) - we’ll have a certain number of free tickets to give out as well.


### Present at SolidusConf
###### Help make this the best SolidusConf yet
We want _you_ to present at SolidusConf this year. We need 6 speakers and 3 workshop presenters. The speaking sessions are traditional 30 to 45 minute spots, while the workshops are more involved - 2 to 3 hours of presentation & instruction, and you’ll have the opportunity to work hand-in-hand with conference attendees. If you’ve got an idea for a talk or a workshop, let us know on [PaperCall](https://www.papercall.io/solidusconf-2020)


### SolidusConf 2020 Sponsorship
###### Show your support for Solidus

These events are only possible with your support! If you’re interested in supporting Solidus, we’re interested in talking with you. Please reach out to [conf@solidus.io](mailto:conf@solidus.io) for more sponsorship information, and to take a look at our sponsorship prospectus. Or, if you're eager, you can go ahead and donate at the tier you want [here](https://opencollective.com/solidus/events/solidusconf-2020-c8147b09).

Announcing SolidusConf 2020

We've released Solidus
[2.10.2](https://github.com/solidusio/solidus/releases/tag/v2.10.2),
[2.9.6](https://github.com/solidusio/solidus/releases/tag/v2.9.6), and
[2.8.6](https://github.com/solidusio/solidus/releases/tag/v2.8.6)
to address a security vulnerability affecting all versions of Solidus.

The releases contain only one patch that addresses CVE-2020-15109.
You can read about CVE-2020-15109 on the [solidus mailing list](https://groups.google.com/forum/#!forum/solidus-security).

If you have any questions about how to secure your site please stop by our Slack [http://slack.solidus.io/](http://slack.solidus.io/).

Have a nice day!

New Solidus releases to address CVE-2020-15109. Please, update your store soon.

New Solidus releases to address a security vulnerability

Hello again, Solidus community! Here we are, with our usual roadmap update — this time, it's the Q2
2020 edition. We have tons of exciting news for you, so buckle your seat belts!

### Now available: data importer, content and GraphQL!

Last Friday marked the initial releases of three *huge* projects that we've been working on for the
last months:

- [solidus_importer](https://github.com/nebulab/solidus_importer): if you've ever worked on
  importing large amounts of data into Solidus (e.g. for a replatform), you know how repetitive and
  error-prone the process can be. Our shiny new data importer, compatible with most major eCommerce
  platforms, should make that much easier! Did we mention it's fully extensible?
- [solidus_content](https://github.com/nebulab/solidus_content): Solidus finally has an _omakase_
  solution for content management. If you need to integrate with Contentful, Prismic, Alchemy or
  any other content management solution, you can use solidus_content to streamline the process and
  create a nice backend UI to manage content. Check it out!
- [solidus\_graphql\_api](https://github.com/solidusio-contrib/solidus_graphql_api): the GraphQL API
  marks the beginning of a new era of headless eCommerce for Solidus. It's now feature-complete and
  ready to see some production traffic. If you're starting a new headless architecture with Solidus,
  you should definitely give it a try — and don't forget to leave feedback!

### Back in business: Klarna and solidus_subscriptions

In addition to releasing the new extensions, we also worked hard to bring home and polish some
popular community-maintained extensions:

- [solidus\_klarna\_payments](https://github.com/solidusio-contrib/solidus_klarna_payments):
  originally developed by [@josetonyp](https://github.com/josetonyp) and
  [@robinboening](https://github.com/robinboening), this extension adds support for
  [Klarna](https://www.klarna.com), a popular payment gateway in Europe. The authors were kind
  enough to let us move the code to solidusio-contrib, where the community gave it new life and made
  it compatible with the latest Solidus releases.
- [solidus_subscriptions](https://github.com/solidusio-contrib/solidus_subscriptions): originally
  developed by Stembolt for [Goby](https://goby.co), our subscriptions extension hadn't seen much
  love in a while. Things are much better now: the extension has been updated, tons of new features
  have been implemented and tons more are coming.

### To Q3 and beyond!

We have so much in store _(pun intended)_ for the next months.

In Q3, we will continue to iterate on the extensions we have released, based on community feedback
and any requirements and edgde cases that emerge from production usage.

However, we won't just rest on our laurels: the next quarter is also when we'll focus on our
omnichannel strategy, making it easier than ever to keep your Solidus catalog in sync with major
platforms such as Amazon, Facebook and Instagram.

We'll also continue working on extendability, improving Solidus' event-driven architecture, and on
enabling support for the latest frontend technologies through our Next.js starter kit.

Finally, we'll complete and publish our new [developer guides](https://guides.solidus.io), which
will not only lower the barrier of entry for becoming a Solidus developer, but also shine a new
light on many of Solidus' lesser-known features and capabilities.

### As always: thank you! 🙇‍

We can't stress this enough: thank you, thank you, thank you. To everyone who's helped with their
contributions, both technical and financial, to everyone who's given us feedback and to everyone
who's shared their appreciation for the community's work. You drive us forward and bring out the
best in us.

Stay tuned for updates via [our blog](/blog) and newsletter, and [reach out on
Slack](https://slack.solidus.io/) if you have any questions, want to help, or just feel the urge to
share some love!

Let's continue shaping the future of eCommerce — free, open-source and community-driven.

Check out the progress we've made towards our roadmap in Q2 2020!

Solidus Roadmap Update: Q2 2020

Affirm provides merchants with an option to offer payment installments. In fact, Solidus has been supporting this with the [official extension for Affirm](https://github.com/solidusio/solidus_affirm) since November 2016!

Did you know using Affirm will increase your Average Order Value (AOV)? Not only that, but it also improves the repeating customer and NPS rates.

![Affirm Numbers](https://cdn.sanity.io/images/9g5nd6b4/production/398f4c932d76ca8d384088418cb8d87a15c7a081-1280x783.png?fit=clip&q=60)

A couple of weeks ago, we started developing [a new version](https://github.com/solidusio-contrib/solidus_affirm_v2). This new version has been refactored and upgraded to use the new [Affirm Transaction API](https://docs.affirm.com/affirm-developers/changelog/transactions-api).

The work for this extension is coordinated by the [Solidus Stakeholders](https://solidus.io/community) and funded by the [Solidus Open Collective Fund](https://opencollective.com/solidus).


With this extension merchants will also be able to use lease-to-own (LTO) providers who partnered with Affirm. Please reach out to Affirm directly to request access for any LTO partners. This is currently in beta at Affirm and not available by default just yet. The Affirm V2 extension supports LTO out of the box.

The following example shows how easy it is to add the Affirm promotional messaging to your storefront.

First we have to generate a view override for the cart partial, in this sample we want to show the Affirm payment option under the price.

We can generate our override like this:
```
bundle exec rails g solidus:views:override --only products/_cart_form
```
(for more information about customizing your storefront see the [customization guide](https://legacy-guides.solidus.io/developers/customizations/customizing-storefront.html) )

This file will be in `app/views/spree/products/_cart_form.html.erb`. To show the Affirm promotional messaging, we will need to load `Affirm.js`.

Luckily, the Solidus extension already takes care of this for you by providing a partial to configure and load `Affirm.js` in the `head` element of your storefront. By default it will only load this in the payment step, but for this specific sample we will be adding it at the top of our generated partial like so:

```
<% render partial: 'solidus_affirm_v2/affirm_js' %>

<%= form_for :order, url: populate_orders_path do |f| %>
  <div id="inside-product-cart-form" data-hook="inside_product_cart_form" itemprop="offers" itemscope itemtype="http://schema.org/Offer">
```

The next, and last step, is to add an html element at the spot where we want to list the Affirm message. There are a lot of options we can use; you can find the documentation for all the html element options at this link [Affirm HTML Ref](https://docs.affirm.com/affirm-developers/docs/html-reference)

We will have to make sure to set the html class to `affirm-as-low-as`, specify the `data-page`, and set the `data-amount` attribute to the product price. The `data-amount` has to be in cents.

```
<div id="affirm-message" class="affirm-as-low-as" data-page-type="product" data-amount="<%=@product.price * 100%>"></div>
```

Refresh the page and visit a product detail page and voila:

![Product Detail Page with Affirm]((https://cdn.sanity.io/images/9g5nd6b4/production/28116992b91127697f5eb784e44862adf2e8347a-1280x783.png?fit=clip&q=60)

When the customer clicks the 'Prequalify now' link, they will get a popup window that shows all the options:

![Affirm Payment Options Popup](https://cdn.sanity.io/images/9g5nd6b4/production/1e2f917044c882dc9a5805781f44ecdf1185d597-1280x783.png?fit=clip&q=60)

Note that in this sample we only see 2 options, this is because the amount is too low for 12-month terms.

When checking out, there is an option now to use Affirm:

![Checkout Payment Step with Affirm](https://cdn.sanity.io/images/9g5nd6b4/production/579eb93eb0011f357bc105b7a87fa82870cdee80-1280x783.png?fit=clip&q=60)

When the customer clicks save and continue, they will be redirected to Affirm to complete the payment there.

When completed with Affirm and confirmed on the Solidus storefront, the payment information will show up in the admin (after capturing) like so:

![Admin Payment Completed with Affirm](https://cdn.sanity.io/images/9g5nd6b4/production/6bb1700dee18ff895bf809d8dbf86dfe3a6d5c00-1280x783.png?fit=clip&q=60)

When clicking on the payment identifier link, you can see more details:

![Admin Payment Details Page with Affirm](https://cdn.sanity.io/images/9g5nd6b4/production/c69162b0c3fe177d9e37acbbb0e7af5403fff812-1280x783.png?fit=clip&q=60)

More information and documentation can be found with the following links:

- [Affirm Merchant](https://www.affirm.com/business)
- [Official Solidus Affirm Extension](https://github.com/solidusio/solidus_affirm)
- [Affirm V2 Extension](https://github.com/solidusio-contrib/solidus_affirm_v2)
- [Solidus Customizations Guide](https://legacy-guides.solidus.io/developers/customizations/overview.html)
- [Affirm Promotion Messages](https://docs.affirm.com/affirm-developers/docs/promo-messaging-getting-started)

Increase revenue by accepting payment instalments on your Solidus store with Affirm and prepare for lease-to-own (LTO) providers.

Increase revenue by accepting payment installments with Affirm.

Hello everyone, and welcome to the second edition of This Month in Solidus, May 2020 edition!

Tons of exciting news this month: we have a new member in the core team, 2.11 is on its way with
tons of improvements, and we're hosting our very first Community Day.

### Jared Norman joins the core team

[Jared](https://github.com/jarednorman) is the owner of Super Good Software, long-time friends of
the Solidus community and among the largest technical and financial contributors to the platform.
Jared has been doing an amazing work in the last few weeks by helping us triage issues and PRs.

It only seemed natural to make things official by inviting him to join the core team, where he'll be
able to continue supporting the Solidus core and extensions ecosystem.

Welcome, Jared! 👋

### Solidus 2.11 is on its way!

You may have noticed the core team is busy working on the [2.11 release](https://github.com/solidusio/solidus/milestone/20).
This is a special release for a couple of reasons: first of all, it comes with tons of performance
enhancements, feature improvements and bug fixes across the board.

Bust most importantly, **this is the last release in the 2.x branch! 🎊** Yep, you read that right!
2.11 paves the way for the much anticipated 3.0 release.

Now, if you know anything about Solidus, you know how much we care about backwards compatibility and
not breaking your apps. This is why we plan to introduce any new features and enhancements in 2.11,
whereas 3.0 will simply remove all deprecated APIs from the code.

The idea is that, if you're on 2.11 and not seeing any deprecation warnings, you can safely update
to Solidus 3.0 and everything will keep working!

### Core updates in May

Here are some of the new features and enhancements introduced in May: 

- [**Restrict shipping methods to stock locations.**](https://github.com/solidusio/solidus/pull/3624)
  It is now possible to restrict shipping methods to select stock locations rather than displaying
  them for all stock locations. Thanks to Dumitru Ceban from Nebulab for uncovering this hidden gem
  in the code and creating a UI to allow anyone to use it!
- [**Pagination in the stock locations UI.**](https://github.com/solidusio/solidus/pull/3600) The
  Stock Locations page in the backend was missing a pagination UI, which was causing issues for
  stores with a high number of stock locations. Thanks to Edwin Cruz from MagmaLabs for taking care
  of the problem!
- [**Configurable guest token cookie options.**](https://github.com/solidusio/solidus/pull/3621) If
  you need to configure the parameters of the guest token cookie, you can now do it via a handy
  Solidus preference. This is very useful if you need to change the domain of the cookie, for
  example. Thanks to Thomas von Deyen for the new feature!
- [**Order validation during updates.**](https://github.com/solidusio/solidus/pull/3645) We know how
  important data integrity is to you. With this change, the order is re-validated every time the
  order updater is run, to make sure you're not inadvertently saving bad data. Thanks to Alberto
  Vena from Nebulab for restoring and finalizing this PR!
- [**"Only Active" filter in promotions UI.**](https://github.com/solidusio/solidus/pull/3595) You
  can now filter promotions by their state, and only get the ones that are currently active. This is
  extremely useful for stores that use promotions heavily — sorting through the list should be much
  easier now. Thanks to @wildbillcat for the feature!

You can expect to see these and many more in 2.11!

### Introducing Solidus Community Day!

In order to bring the amazing Solidus community together more often, **we're setting up a Solidus
Community Day on June 12th,** where you'll be able to talk about the current state of Solidus, the
future of the platform, as well as meet and network with eCommerce industry experts. We'll also have
speaker sessions where you'll be able to hear from Solidus experts about any number of topics.

**This month, we've got Solidus expert Peter Berkenbosch.** Peter is an open-source and eCommerce
veteran who's been working with Spree and Solidus for over a decade. He's specialized in bridging
product, leadership and development to create high-quality eCommerce stacks. He's a CXOps
enthusiast and is passionate about building technology teams and empower them to be their best.

**Peter is going to talk about solidus_dev_support** and how it supports developers in creating
Solidus extensions. He'll be generating an extension from scratch and highlighting the features that
come out of the box with solidus\_dev\_support.

We want to make this a monthly event, so we hope you'll join us in making this Solidus Community Day
a success. [**You can sign up here. See you there!**](https://live.remo.co/e/solidus-community-day-1)

Dive in and see everything that happened in the Solidus world in May 2020: a new release on its way, backend improvements and our very first Community Day!

This Month in Solidus: May 2020

## Introducing Solidus Community Day!

In an effort to bring the amazing Solidus community together more often, we’re setting up a 100% free Solidus Community Day on June 12th, where you’ll be able to talk about the current state of Solidus, the future of Solidus, or just meet & network with eCommerce industry experts. We’ll also have speaker sessions where you’ll be able to hear from Solidus experts about any number of topics.

This month, we’ve got Solidus expert *Peter Berkenbosch*. Peter is an open source eCommerce veteran working with Spree and Solidus frameworks for over a decade, specialized in bridging customers, leadership and development in providing high quality eCommerce stacks. He's a CXOps enthusiast, and passionate in building technology teams and empower them to be the best. 

Peter is going to talk about solidus\_dev\_support and how it supports devs. He'll be generating an extension from scratch and highlighting the features that come out of the box with solidus\_dev\_support.

We’re hoping to make this a monthly event, so we hope you’ll join us in making this Solidus Community Day a success. [You can sign up here](https://live.remo.co/e/solidus-community-day-1) - we hope to see you there! 

Solidus is hosting a brand new, completely free Community Day on June 12th, and we want to see you there!

Solidus Community Day

Hello folks, and welcome to our first edition of This Month in Solidus!

As you may guess from the name, this is a monthly blog post we'll be publishing with news from the
entire Solidus ecosystem. The goal is to keep you in the loop about what's happening and make sure
you take advantage of all the latest opportunities Solidus and its community provide you.

Without further ado, here's what happened in the Solidus world in April 2020!

### Community

You have probably noticed we have started rolling out a complete revamp of our website. It's
important to note this isn't just a cosmetic change: we are completely restructuring our
communication and tone of voice to highlight Solidus' benefits and make the framework more
accessible to non-technical audiences:

* We started with our [home page](https://solidus.io), which was rebuilt from scratch in order to
  clearly communicate the advantages of Solidus for both developers and business stakeholders.
* We then created an [Integrations page](https://solidus.io/integrations), where you can clearly see
  which services Solidus integrates with, and how you can use such integrations to create value for
  your business.
* The real star, however, has been our [Roadmap page](https://solidus.io/roadmap). We have always
  been big on transparency in this community, so it just seemed right to publicly advertise our
  technical roadmap for 2020 — now, the entire community can see what we're up to and what our plans
  are for the rest of the year.

The new website is seeing a tremendous response among the community, and we're really thankful for
all the feedback and enthusiasm that you have shown so far! We still have much more to show you, so
be on the lookup for new pages! 👀

A big thank you to Davide Di Stefano, Michela Frecchiami and everyone else at Nebulab who's helped
with the new design and copy, and to everyone in the Solidus community who's helped us with reviews
and adjustments.

Finally, we've been working on a [demo site](http://demo.solidus.io/), where you can preview
the admin side of Solidus without having to spin up your own server. You're also able to take a
guided tour of some of our favorite features of the platform. It's still very much a work in
progress, but we invite you to take a look and let us know what you think. Shoutout to Sean Denny
from Nebulab for leading this!

### Core

We shipped some exciting improvements that had been anticipated in the
[Q1 roadmap update:](https://solidus.io/blog/2020/04/06/solidus-roadmap-update-q1-2020-edition.html)

* [**ActiveStorage support was merged.**](https://github.com/solidusio/solidus/pull/3501) Support
  for ActiveStorage was finalized and merged into the core. ActiveStorage will be the official
  default starting from Rails 6.1, which will introduce the ability to generate public URLs for
  attachments. Thanks to Elia Schito and Filippo Liverani from Nebulab for their work on this!
* [**Paranoia will be removed in Solidus 3.**](https://github.com/solidusio/solidus/pull/3488)
  Paranoia-style soft-deletion, where deleted records are completely removed from the default scope,
  is now considered a bad practice. We prepared a PR for Solidus 3 that will completely remove
  Paranoia from the core in favor of the more explicit and intentional [Discard](https://github.com/jhawthorn/discard)
  gem. Thanks to Dumitru Ceban from Nebulab!
* **We added support for international names.** Not all names are made by two words, and we want
  Solidus to be respectful and inclusive of these differences. With [these](https://github.com/solidusio/solidus/pull/3458)
  [three](https://github.com/solidusio/solidus/pull/3524) [PRs](https://github.com/solidusio/solidus/pull/3584),
  we added support for more complex names — all while maintaining full backwards compatibility.
  Thanks to Filippo Liverani from Nebulab for his dedication to this matter!

This month, core also saw a huge amount of issue/PR triaging and finalization work. We resumed work
on some old issues and PRs that had been forgotten, and made sure that those that are open are still
relevant. Thanks a lot to Jared Norman from Super Good Software, Edwin Cruz from MagmaLabs and all
the other contributors who helped us with the spring cleaning!

### Extensions

It's been an exciting month in the world of Solidus extensions, with a ton of progress done on our
roadmap goals:

* **Data importer:** our first stable release of [`solidus_importer`](https://github.com/nebulab/solidus_importer)
  is expected this week! You will be able to import users, products and orders, along with all
  related data such as taxons, variants, images, option types and so on. Our next focus will be the
  ability to _export_ data as well. Thanks to Mattia Roccoberton and Flavio Auciello from Nebulab!
* **Content management:** [`solidus_content`](https://github.com/nebulab/solidus_content) now
  integrates with Contentful, Prismic, static sources such as YAML and JSON and, of course, the old
  and beloved solidus_static_content extension. We are now working on the admin UI to make it easier
  to create content types and entries without any development work. Thanks to Elia Schito and Andrea
  Vassallo from Nebulab!
* **Segment integration:** we have started work on our new [`solidus_segment`](https://github.com/nebulab/solidus_segment)
  extension, which uses Solidus' brand new [event bus](https://solidus.io/blog/2020/03/23/solidus-events.html)
  to send order events and other analytics information to Segment. From Segment, it's easy to
  forward the data to your tools of choice — no development work required. Thanks to Alessio Rocco
  from Nebulab!
* **New storefront:** our new [`solidus_starter_frontend`](https://github.com/nebulab/solidus_starter_frontend)
  is almost ready for some action! With semantic structure, a fresh design and more sensible
  defaults, the new storefront sets the foundation for modern frontend support in Solidus. We are
  finalizing the checkout flow and still need to polish some rough edges, but we expect to have
  exciting news soon! Thanks to Dino Hamzić and Paolo Tatone from Nebulab for leading this
  initiative!
* **GraphQL API:** the [`solidus_graphql_api`](https://github.com/solidusio-contrib/solidus_graphql_api)
  team is also working on finalizing the checkout flow. Once that's out of the way, we'll focus our
  efforts on documenting all types and mutations properly, and making sure that hte documentation is
  easily accessible, just like for the REST API. Thanks to Christian Rimondi, Rainer Dema, Alessio
  Rocco and Samuel Martini from Nebulab for the hard work!
* **Affirm:** the new [`solidus_affirm_v2`](https://github.com/peterberkenbosch/solidus_affirm_v2)
  has been refactored and upgraded to use the new Transaction API from Affirm to be able to use
  lease-to-own (LTO) providers partnered with Affirm. This partnership is in selective beta at
  Affirm right now, when publicly available this extension will be able to connect with those
  partners out-of-the-box. Thanks to Peter Berkenbosch, whose work is sponsored by our
  [Open Collective fund](https://opencollective.com/solidus)!
* **Product kits:** the new [`solidus_kits`](https://gitlab.com/deseretbook/solidus_kits) is a
  complete rewrite of the beloved `solidus_product_assembly` and allows you to create product
  bundles/kits to simplify the shopping experience and increase AOV. We have completed the admin UI
  and are now in the final stages of testing. Thanks to the team at Deseret Book for open-sourcing
  this work!

Be on the lookout for initial releases of some of these extensions in May!

### 🎉 SolidusConf 2020 🎉

This year, we're proud to announce that SolidusConf 2020 will be a completely digital experience.
In fact, we're focusing on making this year's conference the most interactive and engaging
SolidusConf yet!

Dates and details are coming soon - stay tuned on the Solidus Slack, this blog and our mailing list
(in the footer) for more information!

Dive in and see everything that happened in the Solidus world in April 2020: tons of core improvements, new extensions, a virtual SolidusConf and much more!

This Month in Solidus: April 2020

As we close the first quarter of the year, we wanted to take some time to share the progress we have
done on our roadmap so far and where we’re headed next.

## Content management

With the rise of content-first eCommerce and so many brands relying on quality content for fostering
a sense of community and brand ownership, we set to work to implement a solution that was flexible
and powerful at the same time.

The result of this work is [solidus_content](https://github.com/nebulab/solidus_content/), the
definitive content management solution for Solidus stores. With its pluggable architecture,
solidus_content allows you to integrate with solidus_static_content, if your use case is simple, or
with more complete solutions such as headless CMSs.

With solidus_content, you can give your content team all the tools they need to create fully dynamic
and nested layouts, creating new opportunities for your brand and dramatically reducing the cost and
time of getting new content up on your website.

## Shopify-compatible importer

Data migration is usually among the largest challenges of an eCommerce replatform project,
especially for stores that have been up and running for some time. Incompatible data structures,
corrupted data, esoteric plugins all make migrating data reliably a huge effort. So far, Solidus
hasn’t had an API in place for simplifying this process.

Our team has been hard at work on [solidus_importer](https://github.com/nebulab/solidus_importer/),
a gem that makes it easier to import data into your Solidus store, either as a one-off task or on a
recurring basis.

solidus_importer is fully compatible with Shopify’s export format because it’s the most widespread.
If your store is on a different platform, there are tools that will convert your data export into
Shopify’s format so that you can use it with the importer.

Did we mention the gem will also support exporting your data, and provide a pluggable architecture
that allows Solidus extensions to define their own import/export logic?

## GraphQL API

The Solidus REST API has served us well for the last five years, allowing us not only to build our
backend, but also countless SPA frontends. However, with the advent of GraphQL and its advantages
over traditional REST architectures, we knew it was time for a new kid on the block.

[Our new GraphQL API](https://github.com/solidusio-contrib/solidus_graphql_api/), while still in
active development, is coming along nicely and will eventually supersede the REST API in all
contexts. It’s already possible to browse a store via GraphQL, and we are currently working on a
GraphQL checkout in order to have a usable MVP ready within the next few weeks.

Our goal is to make it a joy to develop modern frontends backed by Solidus. Which brings us to the
next point…

## New storefront

React and Vue are great frameworks for complex applications, but not every store needs to be a
single page application. In fact, many stores on Solidus are still being developed as traditional
Web apps, with JavaScript in place only to augment and improve the most complex interactions.

For those developers who choose not to use a JavaScript framework, we want to provide a good
out-of-the-box storefront experience that is built following modern frontend development standards,
semantic and easier to customize.

The result of this work is [the new Solidus starter frontend](https://github.com/nebulab/solidus_starter_frontend/),
which will be the foundation for all future frontend work, including our upcoming React and Vue
toolkits.

## Core improvements

A ton of work has also gone into the core in order to make Solidus easier to adopt, customize and
scale:

* [**Paranoia is being deprecated in favor of Discard.**](https://github.com/solidusio/solidus/pull/3488)
  Discard provides a better and more linear developer experience, reducing the likelihood of weird
  bugs and edge cases with soft-deleted records. Paranoia will be completely abandoned in the next
  major release.
* [**Paperclip is being retired in favor of ActiveStorage.**](https://github.com/solidusio/solidus/pull/3501)
  ActiveStorage is the _omakase,_ future-proof solution for file storage. Due to limitations in the
  gem, ActiveStorage will not actually be usable with Solidus until Rails 6.1, but we’ll already
  have support for it by the time it’s released!
* **We’re making [addresses](https://github.com/solidusio/solidus/pull/3465)
  [more](https://github.com/solidusio/solidus/pull/3458)
  [flexible](https://github.com/solidusio/solidus/pull/3524).** This comprises several improvements
  to addresses, including a small but important change in how names are stored and more customizable
  validation rules. These improvements allow better support for international addresses.
* **We’re introducing support for [Apple Pay, Google Pay](https://github.com/solidusio/solidus_stripe/pull/25)
  and [SCA](https://github.com/solidusio/solidus_stripe/pull/20).** Yep, you read that right, three
  in one! solidus_stripe now supports paying via Apple Pay and Google Pay, as well cards that
  require SCA (Strong Customer Authentication). This makes the platform allows stores to continue
  serving customers in Europe, where SCA will be mandatory by the end of 2020.

## What’s next

While we are close to having a stable release for most of these projects, there’s still a lot of
work we need to do in order to finalize the implementations, document them properly and make sure
the community has all the resources they need in order to use the new features.

Having high quality standards means moving a bit more slowly, but also shipping work that
consistently delights our users. In Q2, we will continue to work on these initiatives to get them to
you as soon as possible.

As past initiatives are finalized and released, we will make room for new exciting projects, so be
on the lookout for more blog posts like this one!

## We couldn’t do this without you

Finally, the biggest thank you goes to everyone who’s helped and helps make this project a reality
through their dedication and work: the core team, the contributors, the stakeholders and each and
every single person in the community is absolutely instrumental in the success of Solidus, and we
couldn’t be prouder of being on this journey with you.

If you want to help, you can [ping us on Slack](http://slack.solidus.io/), leave some feedback and
suggestions on the many PRs we are opening across all our repositories, or
[support us financially through OpenCollective!](https://opencollective.com/solidus)

Together, we are shaping the future of eCommerce and, as always, that future is free and open-source.

Check out latest updates on the Solidus Roadmap progress. GraphQL API, Shopify importer, Headless content management and much more.

Solidus Roadmap Update: Q1 2020 Edition

_This post was originally posted on the [Nebulab](https://nebulab.it/) website
[here](https://nebulab.it/blog/five-no-code-ecommerce-management-tools/)._

As an eCommerce consulting firm, we know the value behind a custom store implementation: **not going
with a SaaS solution affords you maximum flexibility and endless innovation opportunities** —
there's nothing a good development team can't do.

For digital brands, this can be powerful: **when your platform doesn't limit you, you can implement
whatever you have in mind,** and create even stronger bonds with your customers.

However, there are also downsides:

* Having a solid development workflow is good for new features and invasive modifications, but it
  becomes a bottleneck when you only need to change an email template, or the arrangement of
  elements on a page. Relying on developers for these tasks can slow you down.
* **Your developers' time is important and, most likely, expensive.** Having them make trivial 
  adjustments to your content or campaigns may not be the best use of their expertise. Instead, you
  should do whatever you can to free them up for more important work.

Luckily, a lot of tools have emerged over the last years that allow you to make changes to almost
every customer-facing aspect of your store without necessarily involving your developers. These are
SaaS tools that only have to be integrated with your store once, and then provide you with an admin
panel you can access and use autonomously.

There are a lot of options for different categories, and over the years we've used many of them for
our customers. Here's a round-up of the best one in each category, along with a few alternatives
you may also want to try!

## 1. Manage your content yourself

Content management is one of those areas where self-serve tools have been available for a long time,
but are not always used (the right way). Headless CMS solutions are all the rage now, and the
philosophy behind them is fairly simple.

Unlike a traditional CMS, that allows editors to enter whatever they want in the page, with the risk
of creating un-optimized or even broken layouts, **headless CMSs require your developers to specify
the possible structure of the content upfront.** Content editors can then manage the content through
the headless CMS. Finally, this content is pulled by your store and displayed to your customers when
they visit the corresponding page(s). 

While they may seem limiting to someone accustomed to old-style content management tools, **headless
CMSs are extremely powerful if used the right way**, and they can be just as flexible, if not more,
than traditional solutions, while sparing your developers a lot of tedious work.

### The best headless CMS: Prismic

![PrismicUI sample](https://cdn.sanity.io/images/9g5nd6b4/production/02a7aca21534757f023a362325426768ca5453a7-1444x848.gif?fit=clip&q=40)

Out of all the headless CMSs we have tried, [Prismic](https://prismic.io) definitely comes out on
top. **It's an extremely modern tool with a powerful API and development toolkits for the most
popular languages, and it can be easily integrated in any application.**

Its pricing is also [very competitive](https://prismic.io/pricing), with a free basic plan and
attractive options for organizations of all shapes and sizes.

There are a couple of alternatives also worth considering:

* [Alchemy CMS](https://alchemy-cms.com/about) is an open-source, self-hosted headless CMS for Ruby
  on Rails applications. It's a good option if you don't want to pay a third-party to host your
  content, but may be more complex for your development team to configure and maintain, especially
  if they don't have experience with Ruby.
* [Contentful](https://www.contentful.com) is Prismic's main competitor. While it's a solid option
  trusted by large companies such as Spotify, Lyft and Twilio, we have found it to be less reliable
  than Prismic, and a bit behind the curve when it comes to its technical capabilities. The pricing
  is also [much steeper](https://www.contentful.com/pricing) than Prismic's, going from $39/mo to
  $879/mo.

## 2. Build 360-degree marketing campaigns

**For digital brands, creating a loyal customer-base that identifies with your values and mission is
a matter of life or death**, and how, when and where you communicate with your users is key to
creating a successful and engaged community of brand _aficionados_.

Unfortunately, very often these touchpoints are hardcoded by developers into the application, which
means every experiment and every change need to go through the development team before customers can
benefit from them. **This can be especially critical for time-sensitive marketing campaigns,** where
getting the timing right can mean the difference between a customer and a lost sale.

Luckily, there are a few tools out there that can help you take back control. The integration flow
is usually straightforward: you ask your developers to send customer information to the marketing
automation service, which you then use to communicate with customers autonomously. 

### The best marketing tool: Klaviyo

![The Klaviyo email marketing UI.](https://cdn.sanity.io/images/9g5nd6b4/production/34c56d7e6b8d6bda3f2dfaf44a6668137211eab0-1395x762.png?fit=clip&q=60)

A relatively recent product, [Klaviyo](https://www.klaviyo.com/) won our hearts when we first used
it, thanks to its flexibility and ease of customization for the end-user.

It allows you to run email, SMS and social media marketing campaigns all from the same interface
and leveraging the same dataset, and (obviously) supports A/B testing of your campaigns so that you
can test small changes and tweak your campaigns accordingly.

But where Klaviyo really shines is in its event-based architecture: by integrating with your store, **Klaviyo knows when your customers take certain actions and allows you to build complex automated campaigns** such as abandoned cart flows, all without having to involve your devs!

The most prominent alternative to Klaviyo is [Mailchimp](https://mailchimp.com), a giant in this industry. While it provides many of Klaviyo's features, Mailchimp lacks SMS marketing capabilities and has other features, such as landing pages and postcards, that may not be needed by the average
brand.

## 3. A/B test to your heart's desire

A/B testing can be a complex feat to pull off properly. Not only do you have to implement the
testing logic, but you also need a solid framework in place to validate the results of your
experiments and ensure you're not jumping to conclusions.

From a technical standpoint, implementing experiments is not fun either: each experiment needs to
be implemented manually, and failed experiments often linger unused in your codebase because no one
has time to remove them. **Over time, this accumulation of failed experiments can create huge
amounts of technical debt and slow down development.**

The complexity behind running a reliable A/B test often puts off companies who'd like to start with
the technique. When done right though, **A/B testing can be a powerful tool to optimize your
conversion rates and get a better sense of your customers' taste**, and there are a few tools you
can use to make this process a breeze.

### The best A/B testing tool: Optimizely

![The Optimizely A/B testing UI.](https://cdn.sanity.io/images/9g5nd6b4/production/1c7ac7dc278e63f43c8fd68b6f1cf66dd6f6101b-1849x1278.png?fit=clip&q=60)

[Optimizely](https://www.optimizely.com/) is an all-in-one platform for A/B testing all aspects of
your website, trusted by the most prominent startups and enterprises. A full-stack implementation
consists of two components:

* A frontend plugin that allows you to **run customer-facing A/B tests without involving your development team**, e.g. testing two versions of your landing page.
* A backend integration that allows your development team to implement A/B tests for more complex aspects, such as testing different promotions or shipping options.

You can manage experiments directly from Optimizely's UI, **which will also determine the winner with its proprietary algorithms** — no Excel spreadsheet needed.

A popular alternative to Optimizely is [LaunchDarkly](https://launchdarkly.com), although you should know LaunchDarkly is more focused on feature flags and does not provide a visual editor that allows you to run customer-facing experiments without asking your developers.

## 4. Up your data collection game

Data is the stepping stone in the journey from online store to digitally-native vertical brand. As Andy Dunn, one of Bonobos' co-founders and
[the man who coined the term _DNVB_](https://medium.com/@dunn/digitally-native-vertical-brands-b26a26f2cf83), says:

> Deeper data on the consumer drives enables the DNVB to stay closer to the customer than its brick
> and mortar driven peers, and the ownership of the brand end-to-end fuels more affinity for a
> vertical commerce brand than even the best e-commerce experiences. 

Being able to do more with your data unlocks new possibilities for your business. In turn, **your
ability to analyze data in a meaningful way is a function of how much data you collect and where.**

Traditionally, adding a new analytics service to your toolbelt has been very dependent on
development work. Developers would have to write a custom integration for the new service and then
test it to make sure data was being collected consistently and reliably. This could result in slow
integration times and lost opportunities.

But in the last few years, a new category tools was born that promise to solve this problem once
and for all. This new breed of services acts as a gateway between your application and all of your
tracking and analytics tools. They provides a unified programming interface that **drastically
simplifies the integration work for your development team,** as they only have to integrate with one
service and not ten. Store owners can then manage all of their tracking integrations from the
gateway's control panel. Adding new services is as simple as clicking a button — no dev needed!

### The best data platform: Segment

![The Segment data collection UI.](https://cdn.sanity.io/images/9g5nd6b4/production/0f94ab549ae2c13cf121a0c26936e899aa9f079d-1121x519.svg?fit=clip&q=60)

[Segment](https://segment.com) touts itself as a customer data platform (CDP). In other words, they provide a centralized data collection service and give you the tools you need to manage and act on your data.

Trusted by tens of startups and large organizations, Segment lives up to its promise of dramatically
simplifying data collection: **developers only have to integrate Segment in your application once.**
You can then enable and test new tracking and analytics services in a blink of an eye, freeing up
your engineering team's time for other initiatives.

In our experience, **Segment is incredibly reliable and provides an amazing user experience.** It
reduces development spend and implementation time.

A popular alternative is [Google Tag Manager](https://tagmanager.google.com/), which allows you to
manage all of your tracking snippets from one interface. However, GTM is much more limited than
Segment, because it simply acts as a central repository for different tracking codes, and doesn't
know anything about the data you are collecting. On the upside, it's free, so it may be a good
starting point if you just want to dip your toes in this water, or if you don't need a full-fledged
data collection platform.

## 5. ...and access new business insights!

Now that customer data is flowing in the right direction(s), it's time to use it to make informed
decisions about your business. In order to do that, many stores develop their internal reporting
tools, which take a lot of time away from core business priorities, or turn to Excel spreadsheets,
which often fall short of business requirements.

Instead, **companies that use data to drive important decisions, such as digitally-native vertical
brands, can and should rely on battle-tested Business Intelligence (BI) platforms.** These are tools
that plug directly into your data sources and can generate reports about all aspects of your
company's operations and sales.

Using a BI platform instead of in-house solutions allows you to access richer insights into your
data and let your developers focusing on core business capabilities rather than internal software.

### The best BI platform: Looker

![The Looker business intelligence UI.](https://cdn.sanity.io/images/9g5nd6b4/production/ad302d86b3f6a04f0641560e3f0bcdc04966649d-942x571.png?fit=clip&q=60)

There's no shortage of BI platforms, as these tools have always been used by companies of all sizes to better understand the market and drive strategic decisions. Among all the options, [Looker](https://looker.com) stands apart for its modern take on business intelligence.

By combining BI, data visualization and reporting capabilities, **Looker allows you to create very flexible experiences:** for instance, you can embed data visualizations directly in your store's dashboard, or send a sales report every month to your key decision-makers, so that everyone's always in the loop and can make the right decisions.

**Looker allows you to access the data you need, wherever you need it,** making sure that reports are being put to good use rather than just sitting there and gathering dust.

[Tableau](https://www.tableau.com) is also worth looking into, although it takes a more traditional approach to business intelligence, centralizing all your data and reports under the same roof.

## Flexibility + automation FTW

Most of these tools have plugins to integrate with the most popular SaaS eCommerce platforms. Unfortunately, **these plugins often offer a shallow integration** that doesn't cover all customer touchpoints or doesn't capture all the data you could leverage.

In some cases, the fault lies on the plugin developer for not doing a good job. In others, it's due to the sandboxed nature of SaaS solutions, that don't expose all the hooks and information the services need to show their full potential.

**By adopting a flexible, open-source eCommerce framework such as [Solidus](https://solidus.io), you are getting the best of both worlds:** on one hand, you can create deep integrations that let you leverage all the features of these awesome services; on the other, you are not limited by your platform, and can implement all those features that make your brand stand apart from its competitors.

As an eCommerce consulting firm, we know the value behind a custom store implementation: not going with a SaaS solution affords you maximum flexibility and endless innovation opportunities — there's nothing a good development team can't do.

5 No-Code eCommerce Management Tools

_This post was originally posted on the [Nebulab](https://nebulab.it/) website
[here](https://nebulab.it/blog/solidus-events/)._

[Event programming][event_programming] (also known as the pub/sub pattern) has been gaining lot of traction in recent times, not without reason. Events allow to easily add custom behavior to a process that the developer may not own directly or know in detail: you just need to subscribe to a known event and then, when it happens, your code will run.

In the past, a few attempts were made to add an events system to
[Solidus][solidus], and finally events became a reality in version 2.9 after
this [PR][solidus_events_pr].

## Solidus events: the basics

How do events work in Solidus? They're actually rather simple, let's start the
Solidus sandbox console and get our hands dirty. First, we need to subscribe to
the event we're insterested in:

```ruby
  Spree::Event.subscribe 'foo' do |event|
    puts "Event with name '#{event.name}' just fired!"
  end
```

then, we can manually fire it:

```ruby
  Spree::Event.fire :foo
```

and the text `Event with name 'foo' just fired!` will appear on your screen...
that was easy 🍰

## Introducing event subscribers

Let's now consider a more ‘real life’ scenario. We want to deliver
[transactional emails][transactional_emails] to customers in a centralized way.

The first step is to patch the state machines of some Solidus models in order
to fire events when the shipment or order state changes. These two modules will
do the trick:

```ruby
  module OrderDecorator
    def self.prepended(base)
      base.state_machine do
        after_transition do |order, transition|
          Spree::Event.fire "order_#{transition.to_name}", order: order
        end
      end
    end

    Spree::Order.prepend(self)
  end

  module ShipmentDecorator
    def self.prepended(base)
      base.state_machine do
        after_transition do |shipment, transition|
          Spree::Event.fire "shipment_#{transition.to_name}", shipment: shipment
        end
      end
    end

    Spree::Shipment.prepend(self)
  end
```

Then, we add a subscriber module that will deliver mails when orders and
shipments change to the right state:

```ruby
  module TransactionalEmailsSubscriber
    include Spree::Event::Subscriber

    event_action :order_complete
    event_action :order_canceled
    event_action :shipment_shipped

    def order_complete(event)
      TransactionalMailer.notify_order(event.payload[:order])
    end

    def order_canceled(event)
      TransactionalMailer.notify_order(event.payload[:order])
    end

    def shipment_shipped(event)
      TransactionalMailer.notify_shipment(event.payload[:shipment])
    end

    subscribe!
  end
```

The module includes `Spree::Event::Subscriber`, which simplifies events
subscriptions by sparing you to write some tedious boilerplate.

You need to define which event you want to subscribe to with the `event_action`
macro and then define a corresponding method that will be called when the event
is triggered.

If the module is loaded late enough in the initialization process of the app,
then it can be subscribed to directly from within its definition (see last
line), otherwise it needs to be explicitly subscribed to, for example in an
initializer:

```ruby
  TransactionalEmailsSubscriber.subscribe!
```

The last and optional step, if you want to actually see the examples work, is
to define the fake `TransactionalMailer` class:

```ruby
  module TransactionalMailer
    extend self

    def notify_order(order)
      puts "Dear #{customer(order)}, your order #{order.number} is now #{order.state}."
    end

    def notify_shipment(shipment)
      order = shipment.order
      puts "Dear #{customer(order)}, shipment with tracking #{shipment.tracking} for order #{order.number} is now #{shipment.state}."
    end

    private

    def customer(order)
      order.bill_address.firstname
    end
  end
```

Everything is now in place, so you just need to complete, cancel or ship some
shipments. One quick way is to copy all the code above in the Solidus core
specs for the order or shipment model, run them and watch the text appear on
screen:
	
![Solidus shipments test run in console](https://cdn.sanity.io/images/9g5nd6b4/production/c2942ea90a563b3bbc39e20150fe4df1aaea0205-1298x730.png?fit=clip&q=60)

## Subscribe to multiple events

Recently Solidus gained the ability to subscribe to multiple events by using
regular expressions. This is a feature made possible by the fact that
ActiveSupportNotifications supports regexps — though other event adapters, when
they will become available, may not offer this feature as well.

Using regular expressions may help, for example, when you want to subscribe
to all order's events, or during debugging. You can use this code if you want
to be notified each time an event is fired:

```ruby
  Spree::Event.subscribe /.*\.spree/ do |event|
    puts "#{event.name} => #{event.payload.inspect}"
  end
```

Please note that you need to explicitly include the `spree` namespace in the
regexp, or you will subscribe to all ActiveSupport notifications, including
the ones from Rails internals.


## How Solidus events work

Solidus events are based on [Rails][rails]'
[ActiveSupportNotifications][ASNotifications], but the actual event backend is
configurable, so new event adapters may be added by the core team in the future
(or you can create your own, of course).

ActiveSupportNotifications seemed to be the most reasonable choice for
implementing the default event adapter for the following reasons:

* it's default Rails
* it's battle tested since Rails 3.x
* it doesn't require any external events library
* it's widely used in Rails internals
* it's simple and easy to use

Solidus events are a relatively new feature, so they still need to become widely
used in the Solidus codebase, but developers can start using them anywhere for
their convenience by adding custom events and subscribing to them. And if you
think you found a good use case, then please consider sharing it with the
community by opening an issue or a PR in Solidus... thank you!


[transactional_emails]: https://en.wikipedia.org/wiki/Email_marketing#Transactional_emails
[solidus_2_9]: https://github.com/solidusio/solidus/tree/v2.9
[solidus]: https://solidus.io/
[ASNotifications]: https://api.rubyonrails.org/classes/ActiveSupport/Notifications.html
[rails]: https://rubyonrails.org/
[event_programming]: https://en.wikipedia.org/wiki/Event_(computing)
[solidus_events_pr]: https://github.com/solidusio/solidus/pull/3081

Event programming (also known as the pub/sub pattern) has been gaining a lot of traction in recent times, not without reason.

The Solidus Blog