I love me some Elixir, but I need to call this out: it’s not magical scaling-sauce that will automatically solve your problems.

It’s easier to write available and scalable code on top of the BEAM, but there are still plenty of traps for the unwary that will produce flaky and/or slow code anyways. For instance:

• using GenServers for code organization (like the docs say NOT to do) and forcing every web request to wait in line at a single process
• misconfiguring supervision trees so that a part of the application that crashes stays crashed until the server is rebooted

Regarding multitenancy, I’d recommend unpacking your requirements in more detail before picking a solution. Some things to think about:

• are the schemas for different customers intended to diverge? If they aren’t, how is your company going to deal with BigCo who needs “just a little customization to close the sale”? Picking a solution that doesn’t match this expectation will lead to a rough time in the future.

• what are the different customers’ service-level expectations? Is your company going to be fine with telling BigCo #2 that the site is down because BigCo #1 sent too many requests? If not, you’ll need to pick a solution that can isolate failures and/or runaway resource consumption.

• are your customers big enough to expect an on-premises option? You don’t have to have an already-writen solution for this, but different multitenancy approaches will make this more painful than others so it’s worth considering early.

Not sure if you read the docs below already but my advise would be to skip libraries like triplex and just handle it yourself.

That said, if you are relatively new to Elixir and multi-tenancy, I would suggest you take a look at the last link, the foreign keys option. This option is the simplest which also means easier to scale.

Another thing which hasn’t been said in the thread already - Phoenix is NOT your application. You might be building a Rails or a Django app but in Elixir Phoenix is just the interface to your business logic. You might want to take a look at the book Designing Elixir Systems with OTP: Write Highly Scalable, Self-Healing Software with Layers by James Edward Gray, II and Bruce A. Tate.