What is it?

A tenant represents a scope for a specific end user of your application. Each tenant should have a 1:1 relationship with a tenant, account, company, or comparable concept in your application. Doohickey-managed integrations are scoped to the tenant level, not the specific application end user level, so any access control to integrations must be handled within your application. (Note: the Doohickey Management Console can be used to managed access control for administrative users.)

Tenants should be strictly scoped to a single tenant in your application. Allowing application tenants to crossover or share data within Doohickey tenants creates potential security vulnerabilities and otherwise makes your integration portfolio harder to manage.

How is it used?

Use tenants to do the following:

  • Scope configured integrations to tenants/accounts/companies just as all other data is scoped within your application.
  • Create a clean separation of concerns between end users within different organizations.
  • Establish a relationship between an application tenant/account/company and the compatible concept within the integration engine.

Why is it important?

Modern software, especially Software-as-a-Service, tends to be multitenant. This model of software distribution has huge advantages for the product team, but it requires a different level of scrutiny for how to keep end user data appropriately segmented. Just like any other data that exists within your application, what applications are enabled and how they are configured, should be strictly scoped by those same principles of multitenancy.

Tenants relate to the following entities:

  • Tenants relate to one or more integration configs, each of which represent an integration that an end user within that tenant has set up and is probably using. Tenants may related to more than one integration config of the same integration definition (e.g. two integrations to separate Shopify accounts).
  • Tenants maintain 1:1 relationships with the compatible entities in both your application and the integration engine. This maintains the same multitenancy principles through the entire system.