diff --git a/ee/app/assets/javascripts/approvals/components/app.vue b/ee/app/assets/javascripts/approvals/components/app.vue
index ada536a7cc7aa5767914fbf77b9e791be7bf2649..d76487e3cd41e679cbedff75ca027978f6065022 100644
--- a/ee/app/assets/javascripts/approvals/components/app.vue
+++ b/ee/app/assets/javascripts/approvals/components/app.vue
@@ -47,7 +47,7 @@ export default {
       </div>
       <div v-if="settings.canEdit" class="border-bottom py-3 px-2">
         <gl-loading-icon v-if="isLoading" />
-        <div class="d-flex">
+        <div v-if="settings.allowMultiRule" class="d-flex">
           <gl-button class="ml-auto btn-info btn-inverted" @click="openCreateModal(null)">{{
             __('Add approvers')
           }}</gl-button>
diff --git a/ee/app/assets/javascripts/approvals/components/fallback_rules.vue b/ee/app/assets/javascripts/approvals/components/fallback_rules.vue
index eb9243307dafcbf99c1a87542f83c4d10d5b390a..54bb2ec7b9262b9c491d5b03da57ecf67108104c 100644
--- a/ee/app/assets/javascripts/approvals/components/fallback_rules.vue
+++ b/ee/app/assets/javascripts/approvals/components/fallback_rules.vue
@@ -50,7 +50,7 @@ export default {
       <td class="pl-0">
         {{ s__('ApprovalRule|All members with Developer role or higher and code owners (if any)') }}
       </td>
-      <td>
+      <td class="text-nowrap">
         <slot
           name="approvals-required"
           :approvals-required="rule.approvalsRequired"
diff --git a/ee/app/assets/javascripts/approvals/components/mr_edit/mr_fallback_rules.vue b/ee/app/assets/javascripts/approvals/components/mr_edit/mr_fallback_rules.vue
index e8cb39a604190e0472bff44b1ab4ae73718db3e7..ee69064288a89b4e36914a961501ef66e784ddc1 100644
--- a/ee/app/assets/javascripts/approvals/components/mr_edit/mr_fallback_rules.vue
+++ b/ee/app/assets/javascripts/approvals/components/mr_edit/mr_fallback_rules.vue
@@ -25,7 +25,7 @@ export default {
       class="form-control mw-6em"
       type="number"
       :min="minApprovalsRequired"
-      @input="putFallbackRule({ approvalsRequired: $event.target.value })"
+      @input="putFallbackRule({ approvalsRequired: Number($event.target.value) })"
     />
   </fallback-rules>
 </template>
diff --git a/ee/app/assets/javascripts/approvals/components/mr_edit/mr_rules.vue b/ee/app/assets/javascripts/approvals/components/mr_edit/mr_rules.vue
index f8dcb048d2daf2b66f72481a508f423e2bfdf3eb..abf164bafccaec399307f34e555df4a573460cc2 100644
--- a/ee/app/assets/javascripts/approvals/components/mr_edit/mr_rules.vue
+++ b/ee/app/assets/javascripts/approvals/components/mr_edit/mr_rules.vue
@@ -18,6 +18,11 @@ export default {
   },
   methods: {
     ...mapActions(['putRule']),
+    canEdit(rule) {
+      const { canEdit, allowMultiRule } = this.settings;
+
+      return canEdit && (!allowMultiRule || !rule.hasSource);
+    },
   },
 };
 </script>
@@ -26,15 +31,17 @@ export default {
   <rules :rules="rules">
     <template slot="thead" slot-scope="{ name, members, approvalsRequired }">
       <tr>
-        <th>{{ name }}</th>
-        <th class="w-50 d-none d-sm-table-cell">{{ members }}</th>
+        <th v-if="settings.allowMultiRule">{{ name }}</th>
+        <th :class="settings.allowMultiRule ? 'w-50 d-none d-sm-table-cell' : 'w-75'">
+          {{ members }}
+        </th>
         <th>{{ approvalsRequired }}</th>
         <th></th>
       </tr>
     </template>
     <template slot="tr" slot-scope="{ rule }">
-      <td class="js-name">{{ rule.name }}</td>
-      <td class="d-none d-sm-table-cell js-members">
+      <td v-if="settings.allowMultiRule" class="js-name">{{ rule.name }}</td>
+      <td class="js-members" :class="settings.allowMultiRule ? 'd-none d-sm-table-cell' : ''">
         <user-avatar-list :items="rule.approvers" :img-size="24" />
       </td>
       <td class="js-approvals-required">
@@ -44,11 +51,11 @@ export default {
           class="form-control mw-6em"
           type="number"
           :min="rule.minApprovalsRequired"
-          @input="putRule({ id: rule.id, approvalsRequired: $event.target.value })"
+          @input="putRule({ id: rule.id, approvalsRequired: Number($event.target.value) })"
         />
       </td>
       <td class="text-nowrap px-2 w-0 js-controls">
-        <rule-controls v-if="settings.canEdit && !rule.hasSource" :rule="rule" />
+        <rule-controls v-if="canEdit(rule)" :rule="rule" />
       </td>
     </template>
   </rules>
diff --git a/ee/app/assets/javascripts/approvals/components/project_settings/project_rules.vue b/ee/app/assets/javascripts/approvals/components/project_settings/project_rules.vue
index 85b2df5b69e5f5f426cb7c858196d106557e4615..b48452b081925975f2835f6d3c3e42725ca53d77 100644
--- a/ee/app/assets/javascripts/approvals/components/project_settings/project_rules.vue
+++ b/ee/app/assets/javascripts/approvals/components/project_settings/project_rules.vue
@@ -14,12 +14,37 @@ export default {
     RuleControls,
   },
   computed: {
+    ...mapState(['settings']),
     ...mapState({
       rules: state => state.approvals.rules,
     }),
   },
   methods: {
     summaryText(rule) {
+      return this.settings.allowMultiRule
+        ? this.summaryMultipleRulesText(rule)
+        : this.summarySingleRuleText(rule);
+    },
+    membersCountText(rule) {
+      return n__(
+        'ApprovalRuleSummary|%d member',
+        'ApprovalRuleSummary|%d members',
+        rule.approvers.length,
+      );
+    },
+    summarySingleRuleText(rule) {
+      const membersCount = this.membersCountText(rule);
+
+      return sprintf(
+        n__(
+          'ApprovalRuleSummary|%{count} approval required from %{membersCount}',
+          'ApprovalRuleSummary|%{count} approvals required from %{membersCount}',
+          rule.approvalsRequired,
+        ),
+        { membersCount, count: rule.approvalsRequired },
+      );
+    },
+    summaryMultipleRulesText(rule) {
       return sprintf(
         n__(
           '%{count} approval required from %{name}',
@@ -37,16 +62,16 @@ export default {
   <rules :rules="rules">
     <template slot="thead" slot-scope="{ name, members, approvalsRequired }">
       <tr class="d-none d-sm-table-row">
-        <th>{{ name }}</th>
+        <th v-if="settings.allowMultiRule">{{ name }}</th>
         <th class="w-50">{{ members }}</th>
         <th>{{ approvalsRequired }}</th>
         <th></th>
       </tr>
     </template>
     <template slot="tr" slot-scope="{ rule }">
-      <td class="js-name">
-        <div class="d-none d-sm-block">{{ rule.name }}</div>
-        <div class="d-block d-sm-none">{{ summaryText(rule) }}</div>
+      <td class="d-table-cell d-sm-none js-summary">{{ summaryText(rule) }}</td>
+      <td v-if="settings.allowMultiRule" class="d-none d-sm-table-cell js-name">
+        {{ rule.name }}
       </td>
       <td class="d-none d-sm-table-cell js-members">
         <user-avatar-list :items="rule.approvers" :img-size="24" />
diff --git a/ee/app/assets/javascripts/approvals/components/rule_controls.vue b/ee/app/assets/javascripts/approvals/components/rule_controls.vue
index b935b41f0825e768c9d68479bd0b0bb21e6178ad..4a123f35474dbe377597454202dab5ee100c58b8 100644
--- a/ee/app/assets/javascripts/approvals/components/rule_controls.vue
+++ b/ee/app/assets/javascripts/approvals/components/rule_controls.vue
@@ -1,5 +1,5 @@
 <script>
-import { mapActions } from 'vuex';
+import { mapState, mapActions } from 'vuex';
 import { GlButton } from '@gitlab/ui';
 import Icon from '~/vue_shared/components/icon.vue';
 
@@ -15,8 +15,9 @@ export default {
     },
   },
   computed: {
+    ...mapState(['settings']),
     isRemoveable() {
-      return !this.rule.isFallback;
+      return !this.rule.isFallback && this.settings.allowMultiRule;
     },
   },
   methods: {
diff --git a/ee/app/assets/javascripts/approvals/components/rule_form.vue b/ee/app/assets/javascripts/approvals/components/rule_form.vue
index 1c3388d40dd091c9b53fb6bc757d1f3616207a8a..9ff9566b9f20e5111f9f2410e15b73aec2718c0e 100644
--- a/ee/app/assets/javascripts/approvals/components/rule_form.vue
+++ b/ee/app/assets/javascripts/approvals/components/rule_form.vue
@@ -7,6 +7,8 @@ import ApproversList from './approvers_list.vue';
 import ApproversSelect from './approvers_select.vue';
 import { TYPE_USER, TYPE_GROUP } from '../constants';
 
+const DEFAULT_NAME = 'Default';
+
 export default {
   components: {
     ApproversList,
@@ -33,7 +35,7 @@ export default {
     };
   },
   computed: {
-    ...mapState({ projectId: state => state.settings.projectId }),
+    ...mapState(['settings']),
     approversByType() {
       return _.groupBy(this.approvers, x => x.type);
     },
@@ -61,7 +63,7 @@ export default {
       };
     },
     invalidName() {
-      if (this.isFallbackSubmission) {
+      if (!this.isMultiSubmission) {
         return '';
       }
 
@@ -83,7 +85,7 @@ export default {
         : '';
     },
     invalidApprovers() {
-      if (this.isFallbackSubmission) {
+      if (!this.isMultiSubmission) {
         return '';
       }
 
@@ -92,12 +94,28 @@ export default {
     isValid() {
       return Object.keys(this.validation).every(key => !this.validation[key]);
     },
+    isMultiSubmission() {
+      return this.settings.allowMultiRule && !this.isFallbackSubmission;
+    },
     isFallbackSubmission() {
-      return this.isFallback && !this.name && !this.approvers.length;
+      return (
+        this.settings.allowMultiRule && this.isFallback && !this.name && !this.approvers.length
+      );
+    },
+    submissionData() {
+      return {
+        id: this.initRule && this.initRule.id,
+        name: this.name || DEFAULT_NAME,
+        approvalsRequired: this.approvalsRequired,
+        users: this.userIds,
+        groups: this.groupIds,
+        userRecords: this.users,
+        groupRecords: this.groups,
+      };
     },
   },
   methods: {
-    ...mapActions(['putFallbackRule', 'postRule', 'putRule']),
+    ...mapActions(['putFallbackRule', 'postRule', 'putRule', 'deleteRule']),
     addSelection() {
       if (!this.approversToAdd.length) {
         return;
@@ -106,30 +124,56 @@ export default {
       this.approvers = this.approversToAdd.concat(this.approvers);
       this.approversToAdd = [];
     },
+    /**
+     * Validate and submit the form based on what type it is.
+     * - Fallback rule?
+     * - Single rule?
+     * - Multi rule?
+     */
     submit() {
       if (!this.validate()) {
         return Promise.resolve();
-      }
-
-      if (this.isFallbackSubmission) {
+      } else if (this.isFallbackSubmission) {
         return this.submitFallback();
+      } else if (!this.isMultiSubmission) {
+        return this.submitSingleRule();
       }
 
-      const id = this.initRule && this.initRule.id;
-      const data = {
-        name: this.name,
-        approvalsRequired: this.approvalsRequired,
-        users: this.userIds,
-        groups: this.groupIds,
-        userRecords: this.users,
-        groupRecords: this.groups,
-      };
+      return this.submitRule();
+    },
+    /**
+     * Submit the rule, by either put-ing or post-ing.
+     */
+    submitRule() {
+      const data = this.submissionData;
 
-      return id ? this.putRule({ id, ...data }) : this.postRule(data);
+      return data.id ? this.putRule(data) : this.postRule(data);
     },
+    /**
+     * Submit as a fallback rule.
+     */
     submitFallback() {
       return this.putFallbackRule({ approvalsRequired: this.approvalsRequired });
     },
+    /**
+     * Submit as a single rule. This is determined by the settings.
+     */
+    submitSingleRule() {
+      if (!this.approvers.length) {
+        return this.submitEmptySingleRule();
+      }
+
+      return this.submitRule();
+    },
+    /**
+     * Submit as a single rule without approvers, so submit the fallback.
+     * Also delete the rule if necessary.
+     */
+    submitEmptySingleRule() {
+      const id = this.initRule && this.initRule.id;
+
+      return Promise.all([this.submitFallback(), id ? this.deleteRule(id) : Promise.resolve()]);
+    },
     validate() {
       this.showValidation = true;
 
@@ -164,7 +208,7 @@ export default {
 <template>
   <form novalidate @submit.prevent.stop="submit">
     <div class="row">
-      <div class="form-group col-sm-6">
+      <div v-if="settings.allowMultiRule" class="form-group col-sm-6">
         <label class="label-wrapper">
           <span class="form-label label-bold">{{ s__('ApprovalRule|Name') }}</span>
           <input
@@ -201,7 +245,7 @@ export default {
         <div class="w-100">
           <approvers-select
             v-model="approversToAdd"
-            :project-id="projectId"
+            :project-id="settings.projectId"
             :skip-user-ids="userIds"
             :skip-group-ids="groupIds"
             :is-invalid="!!validation.approvers"
diff --git a/ee/app/assets/javascripts/approvals/constants.js b/ee/app/assets/javascripts/approvals/constants.js
index 23e2998dad21ca7ea7aa07ec4826750d9de41347..bd8532e23d6c54b8064e4d00183c7f1234e84c19 100644
--- a/ee/app/assets/javascripts/approvals/constants.js
+++ b/ee/app/assets/javascripts/approvals/constants.js
@@ -1,2 +1,6 @@
 export const TYPE_USER = 'user';
 export const TYPE_GROUP = 'group';
+
+export const RULE_TYPE_FALLBACK = 'fallback';
+export const RULE_TYPE_REGULAR = 'regular';
+export const RULE_TYPE_CODE_OWNER = 'code_owner';
diff --git a/ee/app/assets/javascripts/approvals/mappers.js b/ee/app/assets/javascripts/approvals/mappers.js
index c032636581dec0809f533d7c93b2092b9bb96302..27b9c6ed04352a7123fe896064a3d484863edc82 100644
--- a/ee/app/assets/javascripts/approvals/mappers.js
+++ b/ee/app/assets/javascripts/approvals/mappers.js
@@ -1,3 +1,6 @@
+import _ from 'underscore';
+import { RULE_TYPE_REGULAR, RULE_TYPE_FALLBACK } from './constants';
+
 export const mapApprovalRuleRequest = req => ({
   name: req.name,
   approvals_required: req.approvalsRequired,
@@ -18,7 +21,6 @@ export const mapApprovalRuleResponse = res => ({
   approvers: res.approvers,
   users: res.users,
   groups: res.groups,
-  isCodeOwner: res.code_owner,
 });
 
 export const mapApprovalSettingsResponse = res => ({
@@ -27,22 +29,41 @@ export const mapApprovalSettingsResponse = res => ({
 });
 
 /**
- * This is a default rule (from project settings) which implies:
+ * Map the sourced approval rule response for the MR view
+ *
+ * This rule is sourced from project settings, which implies:
  * - Not a real MR rule, so no "id".
  * - The approvals required are the minimum.
  */
-export const mapMRDefaultRule = ({ id, ...rule }) => ({
+export const mapMRSourceRule = ({ id, ...rule }) => ({
   ...rule,
   hasSource: true,
   sourceId: id,
   minApprovalsRequired: rule.approvalsRequired || 0,
 });
 
-export const mapMRApprovalSettingsResponse = res => ({
-  rules: res.rules
-    .map(mapApprovalRuleResponse)
-    .map(res.approval_rules_overwritten ? x => x : mapMRDefaultRule)
-    .filter(x => !x.isCodeOwner),
-  fallbackApprovalsRequired: res.fallback_approvals_required,
-  minFallbackApprovalsRequired: 0,
-});
+/**
+ * Map the approval settings response for the MR view
+ *
+ * - Only show regular rules.
+ * - If needed, extract the fallback approvals required
+ *   from the fallback rule.
+ */
+export const mapMRApprovalSettingsResponse = res => {
+  const rulesByType = _.groupBy(res.rules, x => x.rule_type);
+
+  const regularRules = rulesByType[RULE_TYPE_REGULAR] || [];
+
+  const [fallback] = rulesByType[RULE_TYPE_FALLBACK] || [];
+  const fallbackApprovalsRequired = fallback
+    ? fallback.approvals_required
+    : res.fallback_approvals_required || 0;
+
+  return {
+    rules: regularRules
+      .map(mapApprovalRuleResponse)
+      .map(res.approval_rules_overwritten ? x => x : mapMRSourceRule),
+    fallbackApprovalsRequired,
+    minFallbackApprovalsRequired: 0,
+  };
+};
diff --git a/ee/app/assets/javascripts/approvals/mount_mr_edit.js b/ee/app/assets/javascripts/approvals/mount_mr_edit.js
index ca460547f38952c92d41acfb3691de36f3c6ff9e..62e533ed660ea91779166bac6d64c87c6dd54860 100644
--- a/ee/app/assets/javascripts/approvals/mount_mr_edit.js
+++ b/ee/app/assets/javascripts/approvals/mount_mr_edit.js
@@ -14,8 +14,9 @@ export default function mountApprovalInput(el) {
 
   const store = createStore(mrEditModule(), {
     ...el.dataset,
-    canEdit: parseBoolean(el.dataset.canEdit),
     prefix: 'mr-edit',
+    canEdit: parseBoolean(el.dataset.canEdit),
+    allowMultiRule: parseBoolean(el.dataset.allowMultiRule),
   });
 
   return new Vue({
diff --git a/ee/app/assets/javascripts/approvals/mount_project_settings.js b/ee/app/assets/javascripts/approvals/mount_project_settings.js
index 1518eac480eaf74fb74e54ddd92fe04fd92521af..f8a335bb2859e7d831515d620101625bcb78b60b 100644
--- a/ee/app/assets/javascripts/approvals/mount_project_settings.js
+++ b/ee/app/assets/javascripts/approvals/mount_project_settings.js
@@ -3,6 +3,7 @@ import Vuex from 'vuex';
 import createStore from './stores';
 import projectSettingsModule from './stores/modules/project_settings';
 import ProjectSettingsApp from './components/project_settings/app.vue';
+import { parseBoolean } from '~/lib/utils/common_utils';
 
 Vue.use(Vuex);
 
@@ -12,8 +13,9 @@ export default function mountProjectSettingsApprovals(el) {
   }
 
   const store = createStore(projectSettingsModule(), {
-    prefix: 'project-settings',
     ...el.dataset,
+    prefix: 'project-settings',
+    allowMultiRule: parseBoolean(el.dataset.allowMultiRule),
   });
 
   return new Vue({
diff --git a/ee/app/assets/javascripts/approvals/stores/state.js b/ee/app/assets/javascripts/approvals/stores/state.js
index 5120f75ae337316df44aa63752ee6bee9c341eae..fbde9034beb44512c8af200aa0372c4c970dfebf 100644
--- a/ee/app/assets/javascripts/approvals/stores/state.js
+++ b/ee/app/assets/javascripts/approvals/stores/state.js
@@ -1,5 +1,6 @@
 export const DEFAULT_SETTINGS = {
   canEdit: true,
+  allowMultiRule: false,
 };
 
 export default (settings = {}) => ({
diff --git a/ee/app/assets/javascripts/vue_merge_request_widget/components/approvals/multiple_rule/approvals.vue b/ee/app/assets/javascripts/vue_merge_request_widget/components/approvals/multiple_rule/approvals.vue
index 9e0b7164f9b30a559f19e3fb95f13ad77269ec01..f385c79e95ed6be56fbe2a59daffe899b40b5f02 100644
--- a/ee/app/assets/javascripts/vue_merge_request_widget/components/approvals/multiple_rule/approvals.vue
+++ b/ee/app/assets/javascripts/vue_merge_request_widget/components/approvals/multiple_rule/approvals.vue
@@ -162,7 +162,7 @@ export default {
         </gl-button>
         <approvals-summary
           :approvals-left="mr.approvals.approvals_left"
-          :rules-left="mr.approvals.approval_rules_left"
+          :rules-left="mr.approvals.approvalRuleNamesLeft"
           :approvers="approvedBy"
         />
       </template>
diff --git a/ee/app/assets/javascripts/vue_merge_request_widget/mappers.js b/ee/app/assets/javascripts/vue_merge_request_widget/mappers.js
new file mode 100644
index 0000000000000000000000000000000000000000..2830b77c3f180cc85ce70775ddc3cf18d5915085
--- /dev/null
+++ b/ee/app/assets/javascripts/vue_merge_request_widget/mappers.js
@@ -0,0 +1,42 @@
+import { __ } from '~/locale';
+import { RULE_TYPE_REGULAR, RULE_TYPE_FALLBACK } from 'ee/approvals/constants';
+
+function mapApprovalRule(rule, settings) {
+  if (rule.rule_type === RULE_TYPE_FALLBACK) {
+    // Show a friendly name for the fallback rule
+    return {
+      ...rule,
+      name: __('All Members'),
+      fallback: true,
+    };
+  } else if (rule.rule_type === RULE_TYPE_REGULAR && !settings.multiple_approval_rules_available) {
+    // Give a friendly name to the single rule
+    return {
+      ...rule,
+      name: __('Merge Request'),
+    };
+  }
+
+  return rule;
+}
+
+/**
+ * Map the approval rules response for use by the MR widget
+ */
+export function mapApprovalRulesResponse(rules, settings) {
+  return rules.map(x => mapApprovalRule(x, settings));
+}
+
+/**
+ * Map the overall approvals response for use by the MR widget
+ */
+export function mapApprovalsResponse(data) {
+  return {
+    ...data,
+    // Filter out empty names (fallback rule has no name) because
+    // the empties would look weird.
+    approvalRuleNamesLeft: data.multiple_approval_rules_available
+      ? data.approval_rules_left.map(x => x.name).filter(x => x)
+      : [],
+  };
+}
diff --git a/ee/app/assets/javascripts/vue_merge_request_widget/stores/mr_widget_store.js b/ee/app/assets/javascripts/vue_merge_request_widget/stores/mr_widget_store.js
index b483dc290bc91b98e1bfd73dae6f19d040410b5f..20122db9215109c374fcb7f7a402bc7fa7fd1d85 100644
--- a/ee/app/assets/javascripts/vue_merge_request_widget/stores/mr_widget_store.js
+++ b/ee/app/assets/javascripts/vue_merge_request_widget/stores/mr_widget_store.js
@@ -1,6 +1,6 @@
 import CEMergeRequestStore from '~/vue_merge_request_widget/stores/mr_widget_store';
-import { __ } from '~/locale';
 import { filterByKey } from 'ee/vue_shared/security_reports/store/utils';
+import { mapApprovalsResponse, mapApprovalRulesResponse } from '../mappers';
 
 export default class MergeRequestStore extends CEMergeRequestStore {
   constructor(data) {
@@ -53,29 +53,14 @@ export default class MergeRequestStore extends CEMergeRequestStore {
   }
 
   setApprovals(data) {
-    this.approvals = data;
+    this.approvals = mapApprovalsResponse(data);
     this.approvalsLeft = !!data.approvals_left;
     this.isApproved = !this.approvalsLeft || false;
     this.preventMerge = this.approvalsRequired && this.approvalsLeft;
   }
 
   setApprovalRules(data) {
-    this.approvalRules = this.selectRules(data);
-  }
-
-  selectRules(data) {
-    return [...(data.use_fallback ? [this.buildFallbackRule(data)] : []), ...data.rules];
-  }
-
-  buildFallbackRule(data) {
-    return {
-      name: __('All Members'),
-      fallback: true,
-      approvers: [],
-      approvals_left: this.approvalsLeft,
-      approvals_required: data.fallback_approvals_required,
-      approved_by: this.approvals.approved_by.map(x => x.user),
-    };
+    this.approvalRules = mapApprovalRulesResponse(data.rules, this.approvals);
   }
 
   initCodeclimate(data) {
diff --git a/ee/app/controllers/ee/projects/merge_requests/application_controller.rb b/ee/app/controllers/ee/projects/merge_requests/application_controller.rb
index 4a3159e99f93c2d488cec4c8693d0b62257fcc59..347478ba526552c3033a64b1d338c7b836034264 100644
--- a/ee/app/controllers/ee/projects/merge_requests/application_controller.rb
+++ b/ee/app/controllers/ee/projects/merge_requests/application_controller.rb
@@ -24,8 +24,9 @@ def merge_request_params_attributes
         end
 
         # If the number of approvals is not greater than the project default, set to
-        # nil, so that we fall back to the project default. If it's not set, we can
-        # let the normal update logic handle this.
+        # the project default, so that we fall back to the project default. And
+        # still allow overriding rules defined at the project level but not allow
+        # a number of approvals lower than what the project defined.
         def clamp_approvals_before_merge(mr_params)
           return mr_params unless mr_params[:approvals_before_merge]
 
@@ -39,8 +40,8 @@ def clamp_approvals_before_merge(mr_params)
                              project
                            end
 
-          if mr_params[:approvals_before_merge].to_i <= target_project.approvals_before_merge
-            mr_params[:approvals_before_merge] = nil
+          if mr_params[:approvals_before_merge].to_i < target_project.min_fallback_approvals
+            mr_params[:approvals_before_merge] = target_project.min_fallback_approvals
           end
 
           mr_params
diff --git a/ee/app/models/approval_merge_request_fallback.rb b/ee/app/models/approval_merge_request_fallback.rb
new file mode 100644
index 0000000000000000000000000000000000000000..971ec95b567feae8cb88bb73110021f8f9701976
--- /dev/null
+++ b/ee/app/models/approval_merge_request_fallback.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+class ApprovalMergeRequestFallback
+  attr_reader :merge_request
+  delegate :approved_by_users, :project, to: :merge_request
+
+  def initialize(merge_request)
+    @merge_request = merge_request
+  end
+
+  # Implements all methods `WrappedApprovalRule` required methods
+  def id
+    'fallback-rule'
+  end
+
+  def name
+    ''
+  end
+
+  def users
+    User.none
+  end
+
+  def groups
+    Group.none
+  end
+
+  def approvals_required
+    @approvals_required ||= [merge_request.approvals_before_merge.to_i,
+                             project.min_fallback_approvals].max
+  end
+
+  def approvals_left
+    @approvals_left ||= [approvals_required - approved_by_users.size, 0].max
+  end
+
+  def approvers
+    []
+  end
+
+  def approved_approvers
+    approved_by_users
+  end
+
+  def approved?
+    approved_approvers.size >= approvals_required
+  end
+
+  def code_owner
+    false
+  end
+
+  def source_rule
+    nil
+  end
+
+  def regular
+    false
+  end
+
+  def rule_type
+    :fallback
+  end
+
+  def project
+    merge_request.target_project
+  end
+end
diff --git a/ee/app/models/approval_state.rb b/ee/app/models/approval_state.rb
index 2c3523e6b76b480d69f2b96019409fcdeff3e6ca..7c43300034dd0bcb5344a797eb85a12b66dc3a2d 100644
--- a/ee/app/models/approval_state.rb
+++ b/ee/app/models/approval_state.rb
@@ -31,7 +31,9 @@ def self.filter_author(users, merge_request)
 
   def wrapped_approval_rules
     strong_memoize(:wrapped_approval_rules) do
-      regular_rules + code_owner_rules
+      result = use_fallback? ? [fallback_rule] : regular_rules
+      result += code_owner_rules
+      result
     end
   end
 
@@ -39,32 +41,40 @@ def has_approval_rules?
     !wrapped_approval_rules.empty?
   end
 
+  # Use the fallback rule if regular rules are empty
   def use_fallback?
     regular_rules.empty?
   end
 
+  def fallback_rule
+    ApprovalMergeRequestFallback.new(merge_request)
+  end
+
+  # If a user only has access to a single approval rule. But the project allows
+  # overriding that rule, we need to allow setting `approvals_before_merge` on
+  # the merge request and validate that instead. So in that case we allow falling
+  # back to a `ApprovalMergeRequestFallback`
+  def single_overridden_project_rule?
+    !project.multiple_approval_rules_available? &&
+      project.can_override_approvers? &&
+      merge_request.approvals_before_merge.present?
+  end
+
+  # Determines which set of rules to use (MR or project)
   def approval_rules_overwritten?
-    merge_request.approval_rules.any?(&:regular?)
+    regular_merge_request_rules.any? || single_overridden_project_rule?
   end
   alias_method :approvers_overwritten?, :approval_rules_overwritten?
 
   def approval_needed?
     return false unless project.feature_available?(:merge_request_approvers)
 
-    result = wrapped_approval_rules.any? { |rule| rule.approvals_required > 0 }
-    result ||= fallback_approvals_required > 0 if use_fallback?
-    result
-  end
-
-  def fallback_approvals_required
-    @fallback_approvals_required ||= [project.approvals_before_merge, merge_request.approvals_before_merge || 0].max
+    wrapped_approval_rules.any? { |rule| rule.approvals_required > 0 }
   end
 
   def approved?
     strong_memoize(:approved) do
-      result = wrapped_approval_rules.all?(&:approved?)
-      result &&= approvals.size >= fallback_approvals_required if use_fallback?
-      result
+      wrapped_approval_rules.all?(&:approved?)
     end
   end
 
@@ -74,9 +84,7 @@ def any_approver_allowed?
 
   def approvals_required
     strong_memoize(:approvals_required) do
-      result = wrapped_approval_rules.sum(&:approvals_required)
-      result = [result, fallback_approvals_required].max if use_fallback?
-      result
+      wrapped_approval_rules.sum(&:approvals_required)
     end
   end
 
@@ -84,9 +92,7 @@ def approvals_required
   # considered approved.
   def approvals_left
     strong_memoize(:approvals_left) do
-      result = wrapped_approval_rules.sum(&:approvals_left)
-      result = [result, fallback_approvals_required - approved_approvers.size].max if use_fallback?
-      result
+      wrapped_approval_rules.sum(&:approvals_left)
     end
   end
 
@@ -156,10 +162,9 @@ def first_regular_rule
 
   def regular_rules
     strong_memoize(:regular_rules) do
-      rule_source = approval_rules_overwritten? ? merge_request : project
-      rules = rule_source.approval_rules.select(&:regular?).sort_by(&:id)
+      rules = approval_rules_overwritten? ? regular_merge_request_rules : regular_project_rules
 
-      unless project.feature_available?(:multiple_approval_rules)
+      unless project.multiple_approval_rules_available?
         rules = rules[0, 1]
       end
 
@@ -167,6 +172,14 @@ def regular_rules
     end
   end
 
+  def regular_merge_request_rules
+    @regular_merge_request_rules ||= merge_request.approval_rules.select(&:regular?).sort_by(&:id)
+  end
+
+  def regular_project_rules
+    @regular_project_rules ||= project.visible_regular_approval_rules.to_a
+  end
+
   def code_owner_rules
     strong_memoize(:code_owner_rules) do
       wrap_rules(merge_request.approval_rules.select(&:code_owner?))
diff --git a/ee/app/models/approval_wrapped_rule.rb b/ee/app/models/approval_wrapped_rule.rb
index a27a29cf29c9172952803ea19385e716959fbe86..f6fa391b780914c021271f4790152d0a94939ac3 100644
--- a/ee/app/models/approval_wrapped_rule.rb
+++ b/ee/app/models/approval_wrapped_rule.rb
@@ -8,7 +8,7 @@ class ApprovalWrappedRule
   attr_reader :merge_request
   attr_reader :approval_rule
 
-  def_delegators :@approval_rule, :id, :name, :users, :groups, :approvals_required, :code_owner, :source_rule
+  def_delegators :@approval_rule, :id, :name, :users, :groups, :approvals_required, :code_owner, :source_rule, :rule_type
 
   def initialize(merge_request, approval_rule)
     @merge_request = merge_request
diff --git a/ee/app/models/concerns/approval_rule_like.rb b/ee/app/models/concerns/approval_rule_like.rb
index 0b1dca87a29beeb2dcd91b13cd197c708f560f68..f5abafd0e76b8d656658568d04268877602ff7de 100644
--- a/ee/app/models/concerns/approval_rule_like.rb
+++ b/ee/app/models/concerns/approval_rule_like.rb
@@ -38,4 +38,8 @@ def remove_member(member)
       groups.delete(member)
     end
   end
+
+  def rule_type
+    @rule_type ||= code_owner ? :code_owner : :regular
+  end
 end
diff --git a/ee/app/models/ee/project.rb b/ee/app/models/ee/project.rb
index dd1333427a1ad35d29b4b356d6bf5a68be647d4f..48ac7ef59072407ae64c6e52622078b08236fdf1 100644
--- a/ee/app/models/ee/project.rb
+++ b/ee/app/models/ee/project.rb
@@ -213,6 +213,10 @@ def multiple_issue_boards_available?
       feature_available?(:multiple_project_issue_boards)
     end
 
+    def multiple_approval_rules_available?
+      feature_available?(:multiple_approval_rules)
+    end
+
     def service_desk_enabled
       ::EE::Gitlab::ServiceDesk.enabled?(project: self) && super
     end
@@ -286,6 +290,23 @@ def approvals_before_merge
       super
     end
 
+    def visible_regular_approval_rules
+      strong_memoize(:visible_regular_approval_rules) do
+        regular_rules = approval_rules.regular.order(:id)
+
+        next regular_rules.take(1) unless multiple_approval_rules_available?
+
+        regular_rules
+      end
+    end
+
+    def min_fallback_approvals
+      strong_memoize(:min_fallback_approvals) do
+        visible_regular_approval_rules.map(&:approvals_required).max ||
+          approvals_before_merge.to_i
+      end
+    end
+
     def reset_approvals_on_push
       super && feature_available?(:merge_request_approvers)
     end
diff --git a/ee/app/views/shared/issuable/_approvals_multiple_rule.html.haml b/ee/app/views/shared/issuable/_approvals_multiple_rule.html.haml
index 4f2d41280c6780b8bae8fb2acfe52d37a8986194..0d74f93b3b02b487a0ae9a0b692fbbc53f0f81de 100644
--- a/ee/app/views/shared/issuable/_approvals_multiple_rule.html.haml
+++ b/ee/app/views/shared/issuable/_approvals_multiple_rule.html.haml
@@ -1,5 +1,6 @@
 #js-mr-approvals-input{ data: { 'project_id': @project.id,
   'can_edit': can?(current_user, :update_approvers, issuable).to_s,
+  'allow_multi_rule': @project.multiple_approval_rules_available?.to_s,
   'mr_id': issuable.iid,
   'mr_settings_path': issuable.iid && api_v4_projects_merge_requests_approval_settings_path(id: @project.id, merge_request_iid: issuable.iid),
   'project_settings_path': api_v4_projects_approval_settings_path(id: @project.id) } }
diff --git a/ee/app/views/shared/merge_request_approvals_settings/_multiple_rules_form.html.haml b/ee/app/views/shared/merge_request_approvals_settings/_multiple_rules_form.html.haml
index 00e3617bd454889bb5ce107ceed64abeecd10df3..5abd3a839db1e9e38ce880fed45355783f5d3c08 100644
--- a/ee/app/views/shared/merge_request_approvals_settings/_multiple_rules_form.html.haml
+++ b/ee/app/views/shared/merge_request_approvals_settings/_multiple_rules_form.html.haml
@@ -4,6 +4,7 @@
   #js-mr-approvals-settings{ data: { 'project_id': @project.id,
     'project_path': api_v4_projects_path(id: @project.id),
     'settings_path': api_v4_projects_approval_settings_path(id: @project.id),
-    'rules_path': api_v4_projects_approval_settings_rules_path(id: @project.id) } }
+    'rules_path': api_v4_projects_approval_settings_rules_path(id: @project.id),
+    'allow_multi_rule': @project.multiple_approval_rules_available?.to_s } }
     .text-center.prepend-top-default
       = sprite_icon('spinner', size: 24, css_class: 'gl-spinner')
diff --git a/ee/lib/ee/api/entities.rb b/ee/lib/ee/api/entities.rb
index 4bee7addeeb9661ccbf5ce4f7532a7591d725d7e..8c8ee3a1897756b57f6605c93ab8f534f3cf79e1 100644
--- a/ee/lib/ee/api/entities.rb
+++ b/ee/lib/ee/api/entities.rb
@@ -243,13 +243,16 @@ class SpecialBoardFilter < Grape::Entity
         expose :title
       end
 
-      class ApprovalRule < Grape::Entity
+      class ApprovalRuleShort < Grape::Entity
+        expose :id, :name, :rule_type
+      end
+
+      class ApprovalRule < ApprovalRuleShort
         def initialize(object, options = {})
           presenter = ::ApprovalRulePresenter.new(object, current_user: options[:current_user])
           super(presenter, options)
         end
 
-        expose :id, :name
         expose :approvers, using: ::API::Entities::UserBasic
         expose :approvals_required
         expose :users, using: ::API::Entities::UserBasic
@@ -273,16 +276,12 @@ class MergeRequestApprovalRules < Grape::Entity
         end
 
         expose :wrapped_approval_rules, as: :rules, using: MergeRequestApprovalRule
-        expose :fallback_approvals_required
-        expose :use_fallback do |approval_state|
-          approval_state.use_fallback?
-        end
       end
 
       # Decorates Project
       class ProjectApprovalRules < Grape::Entity
-        expose :approval_rules, as: :rules, using: ApprovalRule
-        expose :approvals_before_merge, as: :fallback_approvals_required
+        expose :visible_regular_approval_rules, as: :rules, using: ApprovalRule
+        expose :min_fallback_approvals, as: :fallback_approvals_required
       end
 
       # @deprecated
@@ -383,13 +382,15 @@ class ApprovalState < Grape::Entity
           approval_state.can_approve?(options[:current_user])
         end
 
-        expose :approval_rules_left do |approval_state, options|
-          approval_state.approval_rules_left.map(&:name)
-        end
+        expose :approval_rules_left, using: ApprovalRuleShort
 
         expose :has_approval_rules do |approval_state|
           approval_state.has_approval_rules?
         end
+
+        expose :multiple_approval_rules_available do |approval_state|
+          approval_state.project.multiple_approval_rules_available?
+        end
       end
 
       class LdapGroup < Grape::Entity
diff --git a/ee/spec/controllers/projects/merge_requests/creations_controller_spec.rb b/ee/spec/controllers/projects/merge_requests/creations_controller_spec.rb
index f0342033837486bc36087a6a82d4ff2ba3afe78d..543922a50c31ae007d5d61630a393743a96b8272 100644
--- a/ee/spec/controllers/projects/merge_requests/creations_controller_spec.rb
+++ b/ee/spec/controllers/projects/merge_requests/creations_controller_spec.rb
@@ -38,8 +38,8 @@ def create_merge_request(overrides = {})
           create_merge_request(approvals_before_merge: 1)
         end
 
-        it 'sets the param to nil' do
-          expect(created_merge_request.approvals_before_merge).to eq(nil)
+        it 'sets the param to the project value' do
+          expect(created_merge_request.reload.approvals_before_merge).to eq(2)
         end
 
         it 'creates the merge request' do
@@ -53,8 +53,8 @@ def create_merge_request(overrides = {})
           create_merge_request(approvals_before_merge: 2)
         end
 
-        it 'sets the param to nil' do
-          expect(created_merge_request.approvals_before_merge).to eq(nil)
+        it 'sets the param to the correct value' do
+          expect(created_merge_request.reload.approvals_before_merge).to eq(2)
         end
 
         it 'creates the merge request' do
@@ -88,7 +88,7 @@ def create_merge_request(overrides = {})
         end
 
         it 'uses the default from the target project' do
-          expect(created_merge_request.approvals_before_merge).to eq(nil)
+          expect(created_merge_request.reload.approvals_before_merge).to eq(4)
         end
 
         it 'creates the merge request' do
diff --git a/ee/spec/controllers/projects/merge_requests_controller_spec.rb b/ee/spec/controllers/projects/merge_requests_controller_spec.rb
index c7b7a7f1e1e0287062417b8e4bbe2805ee2c277c..0eb46a67ef8830370c6a47999dda7949cddead80 100644
--- a/ee/spec/controllers/projects/merge_requests_controller_spec.rb
+++ b/ee/spec/controllers/projects/merge_requests_controller_spec.rb
@@ -164,6 +164,12 @@ def update_merge_request(params = {})
           expect(merge_request.reload.approvals_before_merge).to eq(2)
         end
 
+        it 'does not allow approvels before merge lower than the project setting' do
+          update_merge_request(approvals_before_merge: 0)
+
+          expect(merge_request.reload.approvals_before_merge).to eq(1)
+        end
+
         it 'creates rules' do
           users = create_list(:user, 3)
           users.each { |user| project.add_developer(user) }
@@ -221,8 +227,8 @@ def update_merge_request(params = {})
             update_merge_request(approvals_before_merge: 1)
           end
 
-          it 'sets the param to nil' do
-            expect(merge_request.approvals_before_merge).to eq(nil)
+          it 'sets the param to the sames as the project' do
+            expect(merge_request.reload.approvals_before_merge).to eq(2)
           end
 
           it 'updates the merge request' do
@@ -236,8 +242,8 @@ def update_merge_request(params = {})
             update_merge_request(approvals_before_merge: 2)
           end
 
-          it 'sets the param to nil' do
-            expect(merge_request.reload.approvals_before_merge).to eq(nil)
+          it 'sets the param to the same as the project' do
+            expect(merge_request.reload.approvals_before_merge).to eq(2)
           end
 
           it 'updates the merge request' do
@@ -287,8 +293,8 @@ def update_merge_request(params = {})
             update_merge_request(approvals_before_merge: 1)
           end
 
-          it 'sets the param to nil' do
-            expect(merge_request.reload.approvals_before_merge).to eq(nil)
+          it 'sets the param to the same as the target project' do
+            expect(merge_request.reload.approvals_before_merge).to eq(2)
           end
 
           it 'updates the merge request' do
@@ -302,8 +308,8 @@ def update_merge_request(params = {})
             update_merge_request(approvals_before_merge: 2)
           end
 
-          it 'sets the param to nil' do
-            expect(merge_request.reload.approvals_before_merge).to eq(nil)
+          it 'sets the param to the same as the target project' do
+            expect(merge_request.reload.approvals_before_merge).to eq(2)
           end
 
           it 'updates the merge request' do
diff --git a/ee/spec/fixtures/api/schemas/public_api/v4/project_approval_rule.json b/ee/spec/fixtures/api/schemas/public_api/v4/project_approval_rule.json
index e3b5b4b020b377f6f09c7ecaa0443aed89e538c5..c8510433db16fbb845c6ad41568d09da0ce7fcb5 100644
--- a/ee/spec/fixtures/api/schemas/public_api/v4/project_approval_rule.json
+++ b/ee/spec/fixtures/api/schemas/public_api/v4/project_approval_rule.json
@@ -4,6 +4,7 @@
     "id": { "type": "integer" },
     "name": { "type": "string" },
     "approvals_required": { "type": "integer" },
+    "rule_type": { "type": "tring" },
     "approvers": {
       "type": "array",
       "items": {
diff --git a/ee/spec/javascripts/approvals/components/app_spec.js b/ee/spec/javascripts/approvals/components/app_spec.js
index bfa696b4880c362ac98d08d5d517dd8ef141fc74..055bcbe65f990704a767c66927f4c9df324a0661 100644
--- a/ee/spec/javascripts/approvals/components/app_spec.js
+++ b/ee/spec/javascripts/approvals/components/app_spec.js
@@ -11,7 +11,6 @@ const localVue = createLocalVue();
 localVue.use(Vuex);
 
 const TEST_RULES_CLASS = 'js-fake-rules';
-const TEST_RULES_SEL = `.${TEST_RULES_CLASS}`;
 const APP_PREFIX = 'lorem-ipsum';
 
 describe('EE Approvals App', () => {
@@ -27,128 +26,149 @@ describe('EE Approvals App', () => {
       sync: false,
     });
   };
+  const findAddButton = () => wrapper.find(GlButton);
+  const findLoadingIcon = () => wrapper.find(GlLoadingIcon);
+  const findRules = () => wrapper.find(`.${TEST_RULES_CLASS}`);
 
   beforeEach(() => {
     slots = {
       rules: `<div class="${TEST_RULES_CLASS}">These are the rules!</div>`,
     };
 
-    store = createStoreOptions(settingsModule(), { canEdit: true, prefix: APP_PREFIX });
-    store.modules.approvals.actions.fetchRules = jasmine.createSpy('fetchRules');
-    store.modules.createModal.actions.open = jasmine.createSpy('createModal/open');
+    store = createStoreOptions(settingsModule(), {
+      canEdit: true,
+      prefix: APP_PREFIX,
+    });
+    spyOn(store.modules.approvals.actions, 'fetchRules');
+    spyOn(store.modules.createModal.actions, 'open');
   });
 
-  it('dispatches fetchRules action on created', () => {
-    expect(store.modules.approvals.actions.fetchRules).not.toHaveBeenCalled();
+  describe('when allow multi rule', () => {
+    beforeEach(() => {
+      store.state.settings.allowMultiRule = true;
+    });
 
-    factory();
+    it('dispatches fetchRules action on created', () => {
+      expect(store.modules.approvals.actions.fetchRules).not.toHaveBeenCalled();
 
-    expect(store.modules.approvals.actions.fetchRules).toHaveBeenCalledTimes(1);
-  });
+      factory();
 
-  it('renders create modal', () => {
-    factory();
+      expect(store.modules.approvals.actions.fetchRules).toHaveBeenCalledTimes(1);
+    });
 
-    const modal = wrapper.find(ModalRuleCreate);
+    it('renders create modal', () => {
+      factory();
 
-    expect(modal.exists()).toBe(true);
-    expect(modal.props('modalId')).toBe(`${APP_PREFIX}-approvals-create-modal`);
-  });
+      const modal = wrapper.find(ModalRuleCreate);
 
-  it('renders delete modal', () => {
-    factory();
+      expect(modal.exists()).toBe(true);
+      expect(modal.props('modalId')).toBe(`${APP_PREFIX}-approvals-create-modal`);
+    });
 
-    const modal = wrapper.find(ModalRuleRemove);
+    it('renders delete modal', () => {
+      factory();
 
-    expect(modal.exists()).toBe(true);
-    expect(modal.props('modalId')).toBe(`${APP_PREFIX}-approvals-remove-modal`);
-  });
+      const modal = wrapper.find(ModalRuleRemove);
 
-  describe('if not loaded', () => {
-    beforeEach(() => {
-      store.modules.approvals.state.hasLoaded = false;
+      expect(modal.exists()).toBe(true);
+      expect(modal.props('modalId')).toBe(`${APP_PREFIX}-approvals-remove-modal`);
     });
 
-    it('shows loading icon', () => {
-      store.modules.approvals.state.isLoading = false;
-      factory();
+    describe('if not loaded', () => {
+      beforeEach(() => {
+        store.modules.approvals.state.hasLoaded = false;
+      });
 
-      expect(wrapper.find(GlLoadingIcon).exists()).toBe(true);
-    });
-  });
+      it('shows loading icon', () => {
+        store.modules.approvals.state.isLoading = false;
+        factory();
 
-  describe('if loaded and empty', () => {
-    beforeEach(() => {
-      store.modules.approvals.state = {
-        hasLoaded: true,
-        rules: [],
-        isLoading: false,
-      };
+        expect(findLoadingIcon().exists()).toBe(true);
+      });
     });
 
-    it('does not show Rules', () => {
-      factory();
+    describe('if loaded and empty', () => {
+      beforeEach(() => {
+        store.modules.approvals.state = {
+          hasLoaded: true,
+          rules: [],
+          isLoading: false,
+        };
+      });
 
-      expect(wrapper.find(`.${TEST_RULES_CLASS}`).exists()).toBe(false);
-    });
+      it('does not show Rules', () => {
+        factory();
 
-    it('shows loading icon if loading', () => {
-      store.modules.approvals.state.isLoading = true;
-      factory();
+        expect(findRules().exists()).toBe(false);
+      });
 
-      expect(wrapper.find(GlLoadingIcon).exists()).toBe(true);
-    });
+      it('shows loading icon if loading', () => {
+        store.modules.approvals.state.isLoading = true;
+        factory();
 
-    it('does not show loading icon if not loading', () => {
-      store.modules.approvals.state.isLoading = false;
-      factory();
+        expect(findLoadingIcon().exists()).toBe(true);
+      });
 
-      expect(wrapper.find(GlLoadingIcon).exists()).toBe(false);
-    });
-  });
+      it('does not show loading icon if not loading', () => {
+        store.modules.approvals.state.isLoading = false;
+        factory();
 
-  describe('if not empty', () => {
-    beforeEach(() => {
-      store.modules.approvals.state.hasLoaded = true;
-      store.modules.approvals.state.rules = [{ id: 1 }];
+        expect(findLoadingIcon().exists()).toBe(false);
+      });
     });
 
-    it('shows rules', () => {
-      factory();
+    describe('if not empty', () => {
+      beforeEach(() => {
+        store.modules.approvals.state.hasLoaded = true;
+        store.modules.approvals.state.rules = [{ id: 1 }];
+      });
 
-      const rules = wrapper.find(TEST_RULES_SEL);
+      it('shows rules', () => {
+        factory();
 
-      expect(rules.exists()).toBe(true);
-    });
+        expect(findRules().exists()).toBe(true);
+      });
 
-    it('renders add button', () => {
-      factory();
+      it('renders add button', () => {
+        factory();
 
-      const button = wrapper.find(GlButton);
+        const button = findAddButton();
 
-      expect(button.exists()).toBe(true);
-      expect(button.text()).toBe('Add approvers');
-    });
+        expect(button.exists()).toBe(true);
+        expect(button.text()).toBe('Add approvers');
+      });
 
-    it('opens create modal when add button is clicked', () => {
-      factory();
+      it('opens create modal when add button is clicked', () => {
+        factory();
+
+        findAddButton().vm.$emit('click');
+
+        expect(store.modules.createModal.actions.open).toHaveBeenCalledWith(
+          jasmine.anything(),
+          null,
+          undefined,
+        );
+      });
 
-      const button = wrapper.find(GlButton);
-      button.vm.$emit('click');
+      it('shows loading icon and rules if loading', () => {
+        store.modules.approvals.state.isLoading = true;
+        factory();
 
-      expect(store.modules.createModal.actions.open).toHaveBeenCalledWith(
-        jasmine.anything(),
-        null,
-        undefined,
-      );
+        expect(findRules().exists()).toBe(true);
+        expect(findLoadingIcon().exists()).toBe(true);
+      });
+    });
+  });
+
+  describe('when allow only single rule', () => {
+    beforeEach(() => {
+      store.state.settings.allowMultiRule = false;
     });
 
-    it('shows loading icon and rules if loading', () => {
-      store.modules.approvals.state.isLoading = true;
+    it('does not render add button', () => {
       factory();
 
-      expect(wrapper.find(TEST_RULES_SEL).exists()).toBe(true);
-      expect(wrapper.find(GlLoadingIcon).exists()).toBe(true);
+      expect(findAddButton().exists()).toBe(false);
     });
   });
 });
diff --git a/ee/spec/javascripts/approvals/components/mr_edit/mr_fallback_rules_spec.js b/ee/spec/javascripts/approvals/components/mr_edit/mr_fallback_rules_spec.js
index d09234a5d009396c66966e5e5f4662d3e68c2a05..89be00305ed038ad392dba3c4c030d85265a7b31 100644
--- a/ee/spec/javascripts/approvals/components/mr_edit/mr_fallback_rules_spec.js
+++ b/ee/spec/javascripts/approvals/components/mr_edit/mr_fallback_rules_spec.js
@@ -83,7 +83,7 @@ describe('EE Approvals MRFallbackRules', () => {
       expect(action).toHaveBeenCalledWith(
         jasmine.anything(),
         {
-          approvalsRequired: nextValue.toString(),
+          approvalsRequired: nextValue,
         },
         undefined,
       );
diff --git a/ee/spec/javascripts/approvals/components/mr_edit/mr_rules_spec.js b/ee/spec/javascripts/approvals/components/mr_edit/mr_rules_spec.js
index 0a0e3af19904d0bab2305350068739c5e3f3cb1e..c77944fda797c183e0f8a1a5989f77bd8bef205a 100644
--- a/ee/spec/javascripts/approvals/components/mr_edit/mr_rules_spec.js
+++ b/ee/spec/javascripts/approvals/components/mr_edit/mr_rules_spec.js
@@ -14,15 +14,10 @@ const localVue = createLocalVue();
 localVue.use(Vuex);
 
 describe('EE Approvals MRRules', () => {
-  let rule;
   let wrapper;
   let store;
 
   const factory = () => {
-    if (rule) {
-      store.modules.approvals.state.rules = [rule];
-    }
-
     wrapper = mount(localVue.extend(MRRules), {
       localVue,
       store: new Vuex.Store(store),
@@ -30,6 +25,16 @@ describe('EE Approvals MRRules', () => {
     });
   };
 
+  const findHeaders = () => wrapper.findAll('thead th').wrappers.map(x => x.text());
+  const findRuleName = () => wrapper.find('td.js-name');
+  const findRuleMembers = () =>
+    wrapper
+      .find('td.js-members')
+      .find(UserAvatarList)
+      .props('items');
+  const findRuleApprovalsRequired = () => wrapper.find('td.js-approvals-required input');
+  const findRuleControls = () => wrapper.find('td.js-controls').find(RuleControls);
+
   beforeEach(() => {
     store = createStoreOptions(MREditModule());
     store.modules.approvals.state = {
@@ -41,97 +46,125 @@ describe('EE Approvals MRRules', () => {
 
   afterEach(() => {
     wrapper.destroy();
-    rule = null;
+    wrapper = null;
   });
 
-  const findHeaders = () => wrapper.findAll('thead th').wrappers.map(x => x.text());
-  const findRuleName = () => wrapper.find('td.js-name').text();
-  const findRuleMembers = () =>
-    wrapper
-      .find('td.js-members')
-      .find(UserAvatarList)
-      .props('items');
-  const findRuleApprovalsRequired = () => wrapper.find('td.js-approvals-required input');
-  const findRuleControls = () => wrapper.find('td.js-controls').find(RuleControls);
-
-  it('renders headers', () => {
-    factory();
-
-    expect(findHeaders()).toEqual([HEADERS.name, HEADERS.members, HEADERS.approvalsRequired, '']);
-  });
-
-  describe('with sourced MR rule', () => {
+  describe('when allow multiple rules', () => {
     beforeEach(() => {
-      rule = createMRRuleWithSource();
-      factory();
+      store.state.settings.allowMultiRule = true;
     });
 
-    it('shows name', () => {
-      expect(findRuleName()).toEqual(rule.name);
-    });
+    it('renders headers', () => {
+      factory();
 
-    it('shows members', () => {
-      expect(findRuleMembers()).toEqual(rule.approvers);
+      expect(findHeaders()).toEqual([HEADERS.name, HEADERS.members, HEADERS.approvalsRequired, '']);
     });
 
-    it('shows approvals required input', () => {
-      const approvalsRequired = findRuleApprovalsRequired();
+    describe('with sourced MR rule', () => {
+      const expected = createMRRuleWithSource();
 
-      expect(Number(approvalsRequired.element.value)).toEqual(rule.approvalsRequired);
-      expect(Number(approvalsRequired.attributes('min'))).toEqual(rule.minApprovalsRequired);
-      expect(approvalsRequired.attributes('disabled')).toBeUndefined();
-    });
+      beforeEach(() => {
+        store.modules.approvals.state.rules = [createMRRuleWithSource()];
+
+        factory();
+      });
+
+      it('shows name', () => {
+        expect(findRuleName().text()).toEqual(expected.name);
+      });
 
-    it('does not show controls', () => {
-      const controls = findRuleControls();
+      it('shows members', () => {
+        expect(findRuleMembers()).toEqual(expected.approvers);
+      });
 
-      expect(controls.exists()).toBe(false);
+      it('shows approvals required input', () => {
+        const approvalsRequired = findRuleApprovalsRequired();
+
+        expect(Number(approvalsRequired.element.value)).toEqual(expected.approvalsRequired);
+        expect(Number(approvalsRequired.attributes('min'))).toEqual(expected.minApprovalsRequired);
+        expect(approvalsRequired.attributes('disabled')).toBeUndefined();
+      });
+
+      it('does not show controls', () => {
+        const controls = findRuleControls();
+
+        expect(controls.exists()).toBe(false);
+      });
+
+      it('dispatches putRule on change of approvals required', () => {
+        const action = store.modules.approvals.actions.putRule;
+        const approvalsRequired = findRuleApprovalsRequired();
+        const newValue = expected.approvalsRequired + 1;
+
+        approvalsRequired.setValue(newValue);
+
+        expect(action).toHaveBeenCalledWith(
+          jasmine.anything(),
+          { id: expected.id, approvalsRequired: newValue },
+          undefined,
+        );
+      });
     });
 
-    it('dispatches putRule on change of approvals required', () => {
-      const action = store.modules.approvals.actions.putRule;
-      const approvalsRequired = findRuleApprovalsRequired();
-      const newValue = rule.approvalsRequired + 1;
+    describe('with custom MR rule', () => {
+      const expected = createMRRule();
+
+      beforeEach(() => {
+        store.modules.approvals.state.rules = [createMRRule()];
+        factory();
+      });
+
+      it('shows controls', () => {
+        const controls = findRuleControls();
+
+        expect(controls.exists()).toBe(true);
+        expect(controls.props('rule')).toEqual(expected);
+      });
+
+      describe('with settings cannot edit', () => {
+        beforeEach(() => {
+          store.state.settings.canEdit = false;
+          factory();
+        });
+
+        it('hides controls', () => {
+          const controls = findRuleControls();
+
+          expect(controls.exists()).toBe(false);
+        });
 
-      approvalsRequired.setValue(newValue);
+        it('disables input', () => {
+          const approvalsRequired = findRuleApprovalsRequired();
 
-      expect(action).toHaveBeenCalledWith(
-        jasmine.anything(),
-        { id: rule.id, approvalsRequired: newValue.toString() },
-        undefined,
-      );
+          expect(approvalsRequired.attributes('disabled')).toBe('disabled');
+        });
+      });
     });
   });
 
-  describe('with custom MR rule', () => {
+  describe('when allow single rule', () => {
     beforeEach(() => {
-      rule = createMRRule();
-      factory();
+      store.state.settings.allowMultiRule = false;
     });
 
-    it('shows controls', () => {
-      const controls = findRuleControls();
+    it('does not show name header', () => {
+      factory();
 
-      expect(controls.exists()).toBe(true);
-      expect(controls.props('rule')).toBe(rule);
+      expect(findHeaders()).not.toContain(HEADERS.name);
     });
 
-    describe('with settings cannot edit', () => {
+    describe('with source rule', () => {
       beforeEach(() => {
-        store.state.settings.canEdit = false;
+        store.modules.approvals.state.rules = [createMRRuleWithSource()];
         factory();
       });
 
-      it('hides controls', () => {
-        const controls = findRuleControls();
-
-        expect(controls.exists()).toBe(false);
+      it('does not show name', () => {
+        expect(findRuleName().exists()).toBe(false);
       });
 
-      it('disables input', () => {
-        const approvalsRequired = findRuleApprovalsRequired();
-
-        expect(approvalsRequired.attributes('disabled')).toBe('disabled');
+      it('shows controls', () => {
+        expect(findRuleControls().exists()).toBe(true);
       });
     });
   });
diff --git a/ee/spec/javascripts/approvals/components/project_settings/project_rules_spec.js b/ee/spec/javascripts/approvals/components/project_settings/project_rules_spec.js
index 3e83ba8278a2486616f645f270e54ba8871f007b..64e30037492074c11f427d2e0829317e0bdeab31 100644
--- a/ee/spec/javascripts/approvals/components/project_settings/project_rules_spec.js
+++ b/ee/spec/javascripts/approvals/components/project_settings/project_rules_spec.js
@@ -1,6 +1,8 @@
 import Vuex from 'vuex';
 import { mount, createLocalVue } from '@vue/test-utils';
 import UserAvatarList from '~/vue_shared/components/user_avatar/user_avatar_list.vue';
+import { createStoreOptions } from 'ee/approvals/stores';
+import projectSettingsModule from 'ee/approvals/stores/modules/project_settings';
 import ProjectRules from 'ee/approvals/components/project_settings/project_rules.vue';
 import RuleControls from 'ee/approvals/components/rule_controls.vue';
 import { createProjectRules } from '../../mocks';
@@ -13,14 +15,15 @@ localVue.use(Vuex);
 const findCell = (tr, name) => tr.find(`td.js-${name}`);
 
 const getRowData = tr => {
+  const summary = findCell(tr, 'summary');
   const name = findCell(tr, 'name');
   const members = findCell(tr, 'members');
   const controls = findCell(tr, 'controls');
   const approvalsRequired = findCell(tr, 'approvals-required');
 
   return {
-    name: name.find('.d-sm-block.d-none').text(),
-    summary: name.find('.d-sm-none.d-block').text(),
+    name: name.text(),
+    summary: summary.text(),
     approvers: members.find(UserAvatarList).props('items'),
     approvalsRequired: Number(approvalsRequired.text()),
     ruleControl: controls.find(RuleControls).props('rule'),
@@ -28,46 +31,71 @@ const getRowData = tr => {
 };
 
 describe('Approvals ProjectRules', () => {
-  let state;
   let wrapper;
+  let store;
 
-  const factory = (options = {}) => {
-    const store = new Vuex.Store({
-      state,
-    });
-
+  const factory = (props = {}) => {
     wrapper = mount(localVue.extend(ProjectRules), {
-      ...options,
+      propsData: props,
       sync: false,
-      store,
+      store: new Vuex.Store(store),
       localVue,
     });
   };
 
   beforeEach(() => {
-    state = {
-      approvals: { rules: TEST_RULES },
-    };
+    store = createStoreOptions(projectSettingsModule());
+    store.modules.approvals.state.rules = TEST_RULES;
   });
 
   afterEach(() => {
     wrapper.destroy();
   });
 
-  it('renders row for each rule', () => {
-    factory();
-
-    const rows = wrapper.findAll('tbody tr');
-    const data = rows.wrappers.map(getRowData);
-
-    expect(data).toEqual(
-      TEST_RULES.map(rule => ({
-        name: rule.name,
-        summary: jasmine.stringMatching(`${rule.approvalsRequired} approval.*from ${rule.name}`),
-        approvalsRequired: rule.approvalsRequired,
-        approvers: rule.approvers,
-        ruleControl: rule,
-      })),
-    );
+  describe('when allow multiple rules', () => {
+    beforeEach(() => {
+      store.state.settings.allowMultiRule = true;
+    });
+
+    it('renders row for each rule', () => {
+      factory();
+
+      const rows = wrapper.findAll('tbody tr');
+      const data = rows.wrappers.map(getRowData);
+
+      expect(data).toEqual(
+        TEST_RULES.map(rule => ({
+          name: rule.name,
+          summary: jasmine.stringMatching(`${rule.approvalsRequired} approval.*from ${rule.name}`),
+          approvalsRequired: rule.approvalsRequired,
+          approvers: rule.approvers,
+          ruleControl: rule,
+        })),
+      );
+    });
+  });
+
+  describe('when only allow single rule', () => {
+    let rule;
+    let row;
+
+    beforeEach(() => {
+      [rule] = TEST_RULES;
+      store.modules.approvals.state.rules = [rule];
+
+      factory();
+
+      row = wrapper.find('tbody tr');
+    });
+
+    it('does not render name', () => {
+      expect(findCell(row, 'name').exists()).toBe(false);
+    });
+
+    it('renders single summary', () => {
+      expect(findCell(row, 'summary').text()).toEqual(
+        `${rule.approvalsRequired} approvals required from ${rule.approvers.length} members`,
+      );
+    });
   });
 });
diff --git a/ee/spec/javascripts/approvals/components/rule_controls_spec.js b/ee/spec/javascripts/approvals/components/rule_controls_spec.js
index a0dc60450feccc4a95471de0cb85c3f274b8b58c..aebc037baf8b85c55cbabb8d42fb8ce6a37d0080 100644
--- a/ee/spec/javascripts/approvals/components/rule_controls_spec.js
+++ b/ee/spec/javascripts/approvals/components/rule_controls_spec.js
@@ -11,9 +11,16 @@ localVue.use(Vuex);
 
 const TEST_RULE = { id: 10 };
 
+const findButtonLabel = button => {
+  const icon = button.find(Icon);
+  return icon.exists() ? icon.attributes('aria-label') : button.text();
+};
+const hasLabel = (button, label) => findButtonLabel(button) === label;
+
 describe('EE Approvals RuleControls', () => {
   let wrapper;
   let store;
+  let actions;
 
   const factory = () => {
     wrapper = shallowMount(localVue.extend(RuleControls), {
@@ -25,75 +32,88 @@ describe('EE Approvals RuleControls', () => {
       sync: false,
     });
   };
-
-  const findButton = label =>
-    wrapper
-      .findAll(GlButton)
-      .filter(x => {
-        const icon = x.find(Icon);
-        const identifier = icon.exists() ? icon.attributes('aria-label') : x.text();
-
-        return identifier === label;
-      })
-      .at(0);
+  const findButtons = () => wrapper.findAll(GlButton);
+  const findButton = label => findButtons().filter(button => hasLabel(button, label)).wrappers[0];
+  const findEditButton = () => findButton('Edit');
+  const findRemoveButton = () => findButton('Remove');
 
   beforeEach(() => {
     store = createStoreOptions(MREditModule());
-    store.modules.approvals.actions.requestEditRule = jasmine.createSpy('requestEditRule');
-    store.modules.approvals.actions.requestDeleteRule = jasmine.createSpy('requestDeleteRule');
+    ({ actions } = store.modules.approvals);
+    ['requestEditRule', 'requestDeleteRule'].forEach(actionName => spyOn(actions, actionName));
   });
 
   afterEach(() => {
     wrapper.destroy();
   });
 
-  describe('edit button', () => {
-    let button;
-
+  describe('when allow multi rule', () => {
     beforeEach(() => {
-      factory();
-      button = findButton('Edit');
+      store.state.settings.allowMultiRule = true;
     });
 
-    it('exists', () => {
-      expect(button.exists()).toBe(true);
+    describe('edit button', () => {
+      let button;
+
+      beforeEach(() => {
+        factory();
+        button = findEditButton();
+      });
+
+      it('exists', () => {
+        expect(button.exists()).toBe(true);
+      });
+
+      it('when click, opens create modal', () => {
+        expect(store.modules.approvals.actions.requestEditRule).not.toHaveBeenCalled();
+
+        button.vm.$emit('click');
+
+        expect(store.modules.approvals.actions.requestEditRule).toHaveBeenCalledWith(
+          jasmine.anything(),
+          TEST_RULE,
+          undefined,
+        );
+      });
     });
 
-    it('when click, opens create modal', () => {
-      expect(store.modules.approvals.actions.requestEditRule).not.toHaveBeenCalled();
+    describe('remove button', () => {
+      let button;
+
+      beforeEach(() => {
+        factory();
+        button = findRemoveButton();
+      });
+
+      it('exists', () => {
+        expect(button.exists()).toBe(true);
+      });
 
-      button.vm.$emit('click');
+      it('when click, opens delete modal', () => {
+        expect(store.modules.approvals.actions.requestDeleteRule).not.toHaveBeenCalled();
 
-      expect(store.modules.approvals.actions.requestEditRule).toHaveBeenCalledWith(
-        jasmine.anything(),
-        TEST_RULE,
-        undefined,
-      );
+        button.vm.$emit('click');
+
+        expect(store.modules.approvals.actions.requestDeleteRule).toHaveBeenCalledWith(
+          jasmine.anything(),
+          TEST_RULE,
+          undefined,
+        );
+      });
     });
   });
 
-  describe('remove button', () => {
-    let button;
-
+  describe('when allow only single rule', () => {
     beforeEach(() => {
       factory();
-      button = findButton('Remove');
     });
 
-    it('exists', () => {
-      expect(button.exists()).toBe(true);
+    it('renders edit button', () => {
+      expect(findEditButton().exists()).toBe(true);
     });
 
-    it('when click, opens delete modal', () => {
-      expect(store.modules.approvals.actions.requestDeleteRule).not.toHaveBeenCalled();
-
-      button.vm.$emit('click');
-
-      expect(store.modules.approvals.actions.requestDeleteRule).toHaveBeenCalledWith(
-        jasmine.anything(),
-        TEST_RULE,
-        undefined,
-      );
+    it('does not render remove button', () => {
+      expect(findRemoveButton()).toBe(undefined);
     });
   });
 });
diff --git a/ee/spec/javascripts/approvals/components/rule_form_spec.js b/ee/spec/javascripts/approvals/components/rule_form_spec.js
index cc52540b84e81b2f8b4fa0e38e535d02c5bbabcb..67ee1fecb7f8139903711958bffd530ee8723522 100644
--- a/ee/spec/javascripts/approvals/components/rule_form_spec.js
+++ b/ee/spec/javascripts/approvals/components/rule_form_spec.js
@@ -1,6 +1,8 @@
 import { shallowMount, createLocalVue } from '@vue/test-utils';
 import Vuex from 'vuex';
 import { GlButton } from '@gitlab/ui';
+import { createStoreOptions } from 'ee/approvals/stores';
+import projectSettingsModule from 'ee/approvals/stores/modules/project_settings';
 import ApproversSelect from 'ee/approvals/components/approvers_select.vue';
 import RuleForm from 'ee/approvals/components/rule_form.vue';
 import { TYPE_USER, TYPE_GROUP } from 'ee/approvals/constants';
@@ -13,186 +15,401 @@ const TEST_RULE = {
   users: [{ id: 1 }, { id: 2 }, { id: 3 }],
   groups: [{ id: 1 }, { id: 2 }],
 };
+const TEST_APPROVERS = [{ id: 7, type: TYPE_USER }];
+const TEST_APPROVALS_REQUIRED = 3;
+const TEST_FALLBACK_RULE = {
+  approvalsRequired: 1,
+  isFallback: true,
+};
 
 const localVue = createLocalVue();
 localVue.use(Vuex);
 
-const wrapInput = node => ({
-  node,
-  feedback: () => node.element.nextElementSibling.textContent,
-  isValid: () => !node.classes('is-invalid'),
-});
-const findInput = (form, selector) => wrapInput(form.find(selector));
-const findNameInput = form => findInput(form, 'input[name=name]');
-const findApprovalsRequiredInput = form => findInput(form, 'input[name=approvals_required]');
-const findApproversSelect = form => {
-  const input = findInput(form, ApproversSelect);
-
-  return {
-    ...input,
-    isValid() {
-      return !input.node.props('isInvalid');
-    },
-  };
-};
-
-describe('Approvals RuleForm', () => {
-  let state;
-  let actions;
+describe('EE Approvals RuleForm', () => {
   let wrapper;
+  let store;
+  let actions;
 
-  const factory = (options = {}) => {
-    const store = new Vuex.Store({
-      state,
-      actions,
-    });
-
+  const createComponent = (props = {}) => {
     wrapper = shallowMount(localVue.extend(RuleForm), {
-      ...options,
+      propsData: props,
+      store: new Vuex.Store(store),
       localVue,
-      store,
+      sync: false,
     });
   };
+  const findValidation = (node, hasProps = false) => ({
+    feedback: node.element.nextElementSibling.textContent,
+    isValid: hasProps ? !node.props('isInvalid') : !node.classes('is-invalid'),
+  });
+  const findNameInput = () => wrapper.find('input[name=name]');
+  const findNameValidation = () => findValidation(findNameInput(), false);
+  const findApprovalsRequiredInput = () => wrapper.find('input[name=approvals_required]');
+  const findApprovalsRequiredValidation = () => findValidation(findApprovalsRequiredInput(), false);
+  const findApproversSelect = () => wrapper.find(ApproversSelect);
+  const findApproversValidation = () => findValidation(findApproversSelect(), true);
+  const findValidations = () => [
+    findNameValidation(),
+    findApprovalsRequiredValidation(),
+    findApproversValidation(),
+  ];
 
   beforeEach(() => {
-    state = {
-      settings: { projectId: TEST_PROJECT_ID },
-    };
-
-    actions = {
-      postRule: jasmine.createSpy('postRule'),
-      putRule: jasmine.createSpy('putRule'),
-    };
+    store = createStoreOptions(projectSettingsModule(), { projectId: TEST_PROJECT_ID });
+
+    ['postRule', 'putRule', 'deleteRule', 'putFallbackRule'].forEach(actionName => {
+      spyOn(store.modules.approvals.actions, actionName);
+    });
+
+    ({ actions } = store.modules.approvals);
   });
 
   afterEach(() => {
     wrapper.destroy();
   });
 
-  describe('without initRule', () => {
+  describe('when allow multiple rules', () => {
     beforeEach(() => {
-      factory();
+      store.state.settings.allowMultiRule = true;
     });
 
-    it('at first, shows no validation', () => {
-      const inputs = [
-        findNameInput(wrapper),
-        findApprovalsRequiredInput(wrapper),
-        findApproversSelect(wrapper),
-      ];
-      const invalidInputs = inputs.filter(x => !x.isValid());
-      const feedbacks = inputs.map(x => x.feedback());
-
-      expect(invalidInputs.length).toBe(0);
-      expect(feedbacks.every(str => !str.length)).toBe(true);
-    });
+    describe('without initRule', () => {
+      beforeEach(() => {
+        createComponent();
+      });
 
-    it('on submit, does not dispatch action', () => {
-      wrapper.vm.submit();
+      it('at first, shows no validation', () => {
+        const inputs = findValidations();
+        const invalidInputs = inputs.filter(x => !x.isValid);
+        const feedbacks = inputs.map(x => x.feedback);
 
-      expect(actions.postRule).not.toHaveBeenCalled();
-    });
+        expect(invalidInputs.length).toBe(0);
+        expect(feedbacks.every(str => !str.length)).toBe(true);
+      });
 
-    it('on submit, shows name validation', () => {
-      const { node, isValid, feedback } = findNameInput(wrapper);
-      node.setValue('');
+      it('on submit, does not dispatch action', () => {
+        wrapper.vm.submit();
 
-      wrapper.vm.submit();
+        expect(actions.postRule).not.toHaveBeenCalled();
+      });
 
-      expect(isValid()).toBe(false);
-      expect(feedback()).toEqual('Please provide a name');
-    });
+      it('on submit, shows name validation', done => {
+        findNameInput().setValue('');
+
+        wrapper.vm.submit();
+
+        localVue
+          .nextTick()
+          .then(() => {
+            expect(findNameValidation()).toEqual({
+              isValid: false,
+              feedback: 'Please provide a name',
+            });
+          })
+          .then(done)
+          .catch(done.fail);
+      });
+
+      it('on submit, shows approvalsRequired validation', done => {
+        findApprovalsRequiredInput().setValue(-1);
+
+        wrapper.vm.submit();
+
+        localVue
+          .nextTick()
+          .then(() => {
+            expect(findApprovalsRequiredValidation()).toEqual({
+              isValid: false,
+              feedback: 'Please enter a non-negative number',
+            });
+          })
+          .then(done)
+          .catch(done.fail);
+      });
 
-    it('on submit, shows approvalsRequired validation', () => {
-      const { node, isValid, feedback } = findApprovalsRequiredInput(wrapper);
-      node.setValue(-1);
+      it('on submit, shows approvers validation', done => {
+        wrapper.vm.approvers = [];
+        wrapper.vm.submit();
+
+        localVue
+          .nextTick()
+          .then(() => {
+            expect(findApproversValidation()).toEqual({
+              isValid: false,
+              feedback: 'Please select and add a member',
+            });
+          })
+          .then(done)
+          .catch(done.fail);
+      });
 
-      wrapper.vm.submit();
+      it('on submit with data, posts rule', () => {
+        const users = [1, 2];
+        const groups = [2, 3];
+        const userRecords = users.map(id => ({ id, type: TYPE_USER }));
+        const groupRecords = groups.map(id => ({ id, type: TYPE_GROUP }));
+        const expected = {
+          id: null,
+          name: 'Lorem',
+          approvalsRequired: 2,
+          users,
+          groups,
+          userRecords,
+          groupRecords,
+        };
+
+        findNameInput().setValue(expected.name);
+        findApprovalsRequiredInput().setValue(expected.approvalsRequired);
+        wrapper.vm.approvers = groupRecords.concat(userRecords);
+
+        wrapper.vm.submit();
+
+        expect(actions.postRule).toHaveBeenCalledWith(jasmine.anything(), expected, undefined);
+      });
 
-      expect(isValid()).toBe(false);
-      expect(feedback()).toEqual('Please enter a non-negative number');
-    });
+      it('adds selected approvers on button click', () => {
+        const selected = [
+          { id: 1, type: TYPE_USER },
+          { id: 2, type: TYPE_USER },
+          { id: 1, type: TYPE_GROUP },
+        ];
+        const orig = [{ id: 7, type: TYPE_GROUP }];
+        const expected = selected.concat(orig);
 
-    it('on submit, shows approvers validation', () => {
-      const { isValid, feedback } = findApproversSelect(wrapper);
-      wrapper.vm.approvers = [];
+        wrapper.vm.approvers = orig;
 
-      wrapper.vm.submit();
+        findApproversSelect().vm.$emit('input', selected);
+        wrapper.find(GlButton).vm.$emit('click');
 
-      expect(isValid()).toBe(false);
-      expect(feedback()).toEqual('Please select and add a member');
+        expect(wrapper.vm.approvers).toEqual(expected);
+      });
     });
 
-    it('on submit with data, posts rule', () => {
-      const users = [1, 2];
-      const groups = [2, 3];
-      const userRecords = users.map(id => ({ id, type: TYPE_USER }));
-      const groupRecords = groups.map(id => ({ id, type: TYPE_GROUP }));
-      const expected = {
-        name: 'Lorem',
-        approvalsRequired: 2,
-        users,
-        groups,
-        userRecords,
-        groupRecords,
-      };
-      const name = findNameInput(wrapper);
-      const approvalsRequired = findApprovalsRequiredInput(wrapper);
-
-      name.node.setValue(expected.name);
-      approvalsRequired.node.setValue(expected.approvalsRequired);
-      wrapper.vm.approvers = groupRecords.concat(userRecords);
-
-      wrapper.vm.submit();
-
-      expect(actions.postRule).toHaveBeenCalledWith(jasmine.anything(), expected, undefined);
+    describe('with initRule', () => {
+      beforeEach(() => {
+        createComponent({
+          initRule: TEST_RULE,
+        });
+      });
+
+      it('on submit, puts rule', () => {
+        const userRecords = TEST_RULE.users.map(x => ({ ...x, type: TYPE_USER }));
+        const groupRecords = TEST_RULE.groups.map(x => ({ ...x, type: TYPE_GROUP }));
+        const users = userRecords.map(x => x.id);
+        const groups = groupRecords.map(x => x.id);
+
+        const expected = {
+          ...TEST_RULE,
+          users,
+          groups,
+          userRecords,
+          groupRecords,
+        };
+
+        wrapper.vm.submit();
+
+        expect(actions.putRule).toHaveBeenCalledWith(jasmine.anything(), expected, undefined);
+      });
     });
 
-    it('adds selected approvers on button click', () => {
-      const { node } = findApproversSelect(wrapper);
-      const selected = [
-        { id: 1, type: TYPE_USER },
-        { id: 2, type: TYPE_USER },
-        { id: 1, type: TYPE_GROUP },
-      ];
-      const orig = [{ id: 7, type: TYPE_GROUP }];
-      const expected = selected.concat(orig);
+    describe('with init fallback rule', () => {
+      beforeEach(() => {
+        createComponent({
+          initRule: TEST_FALLBACK_RULE,
+        });
 
-      wrapper.vm.approvers = orig;
+        wrapper.vm.name = '';
+        wrapper.vm.approvers = [];
+        wrapper.vm.approvalsRequired = TEST_APPROVALS_REQUIRED;
+      });
+
+      describe('with empty name and empty approvers', () => {
+        beforeEach(done => {
+          wrapper.vm.submit();
+          localVue.nextTick(done);
+        });
+
+        it('does not post rule', () => {
+          expect(actions.postRule).not.toHaveBeenCalled();
+        });
+
+        it('puts fallback rule', () => {
+          expect(actions.putFallbackRule).toHaveBeenCalledWith(
+            jasmine.anything(),
+            { approvalsRequired: TEST_APPROVALS_REQUIRED },
+            undefined,
+          );
+        });
+
+        it('does not show any validation errors', () => {
+          expect(findValidations().every(x => x.isValid)).toBe(true);
+        });
+      });
+
+      describe('with name and empty approvers', () => {
+        beforeEach(done => {
+          wrapper.vm.name = 'Lorem';
+          wrapper.vm.submit();
+
+          localVue.nextTick(done);
+        });
+
+        it('does not put fallback rule', () => {
+          expect(actions.putFallbackRule).not.toHaveBeenCalled();
+        });
+
+        it('shows approvers validation error', () => {
+          expect(findApproversValidation().isValid).toBe(false);
+        });
+      });
+
+      describe('with empty name and approvers', () => {
+        beforeEach(done => {
+          wrapper.vm.approvers = TEST_APPROVERS;
+          wrapper.vm.submit();
 
-      node.vm.$emit('input', selected);
-      wrapper.find(GlButton).vm.$emit('click');
+          localVue.nextTick(done);
+        });
 
-      expect(wrapper.vm.approvers).toEqual(expected);
+        it('does not put fallback rule', () => {
+          expect(actions.putFallbackRule).not.toHaveBeenCalled();
+        });
+
+        it('shows name validation error', () => {
+          expect(findNameValidation().isValid).toBe(false);
+        });
+      });
+
+      describe('with name and approvers', () => {
+        beforeEach(done => {
+          wrapper.vm.approvers = [{ id: 7, type: TYPE_USER }];
+          wrapper.vm.name = 'Lorem';
+          wrapper.vm.submit();
+
+          localVue.nextTick(done);
+        });
+
+        it('does not put fallback rule', () => {
+          expect(actions.putFallbackRule).not.toHaveBeenCalled();
+        });
+
+        it('posts new rule', () => {
+          expect(actions.postRule).toHaveBeenCalled();
+        });
+      });
     });
   });
 
-  describe('with initRule', () => {
+  describe('when allow only single rule', () => {
     beforeEach(() => {
-      factory({
-        propsData: {
-          initRule: TEST_RULE,
-        },
-      });
+      store.state.settings.allowMultiRule = false;
+    });
+
+    it('hides name', () => {
+      createComponent();
+
+      expect(findNameInput().exists()).toBe(false);
     });
 
-    it('on submit, puts rule', () => {
-      const userRecords = TEST_RULE.users.map(x => ({ ...x, type: TYPE_USER }));
-      const groupRecords = TEST_RULE.groups.map(x => ({ ...x, type: TYPE_GROUP }));
-      const users = userRecords.map(x => x.id);
-      const groups = groupRecords.map(x => x.id);
+    describe('with no init rule', () => {
+      beforeEach(() => {
+        createComponent();
+        wrapper.vm.approvalsRequired = TEST_APPROVALS_REQUIRED;
+      });
+
+      describe('with approvers selected', () => {
+        beforeEach(done => {
+          wrapper.vm.approvers = TEST_APPROVERS;
+          wrapper.vm.submit();
+
+          localVue.nextTick(done);
+        });
+
+        it('posts new rule', () => {
+          expect(actions.postRule).toHaveBeenCalledWith(
+            jasmine.anything(),
+            jasmine.objectContaining({
+              approvalsRequired: TEST_APPROVALS_REQUIRED,
+              users: TEST_APPROVERS.map(x => x.id),
+            }),
+            undefined,
+          );
+        });
+      });
+
+      describe('without approvers', () => {
+        beforeEach(done => {
+          wrapper.vm.submit();
 
-      const expected = {
-        ...TEST_RULE,
-        users,
-        groups,
-        userRecords,
-        groupRecords,
-      };
+          localVue.nextTick(done);
+        });
 
-      wrapper.vm.submit();
+        it('puts fallback rule', () => {
+          expect(actions.putFallbackRule).toHaveBeenCalledWith(
+            jasmine.anything(),
+            { approvalsRequired: TEST_APPROVALS_REQUIRED },
+            undefined,
+          );
+        });
+      });
+    });
+
+    describe('with init rule', () => {
+      beforeEach(() => {
+        createComponent({
+          initRule: TEST_RULE,
+        });
+        wrapper.vm.approvalsRequired = TEST_APPROVALS_REQUIRED;
+      });
+
+      describe('with empty name and empty approvers', () => {
+        beforeEach(done => {
+          wrapper.vm.name = '';
+          wrapper.vm.approvers = [];
+          wrapper.vm.submit();
+
+          localVue.nextTick(done);
+        });
+
+        it('deletes rule', () => {
+          expect(actions.deleteRule).toHaveBeenCalledWith(
+            jasmine.anything(),
+            TEST_RULE.id,
+            undefined,
+          );
+        });
+
+        it('puts fallback rule', () => {
+          expect(actions.putFallbackRule).toHaveBeenCalledWith(
+            jasmine.anything(),
+            { approvalsRequired: TEST_APPROVALS_REQUIRED },
+            undefined,
+          );
+        });
+      });
 
-      expect(actions.putRule).toHaveBeenCalledWith(jasmine.anything(), expected, undefined);
+      describe('with name and approvers', () => {
+        beforeEach(done => {
+          wrapper.vm.name = 'Bogus';
+          wrapper.vm.approvers = TEST_APPROVERS;
+          wrapper.vm.submit();
+
+          localVue.nextTick(done);
+        });
+
+        it('puts rule', () => {
+          expect(actions.putRule).toHaveBeenCalledWith(
+            jasmine.anything(),
+            jasmine.objectContaining({
+              id: TEST_RULE.id,
+              name: 'Bogus',
+              approvalsRequired: TEST_APPROVALS_REQUIRED,
+              users: TEST_APPROVERS.map(x => x.id),
+            }),
+            undefined,
+          );
+        });
+      });
     });
   });
 });
diff --git a/ee/spec/javascripts/fixtures/merge_requests.rb b/ee/spec/javascripts/fixtures/merge_requests.rb
index dbc2b325abe99abccbc5b2f3de317bac0f7a680e..79a3f497416fcc8e9ef51372b1ddccbc5272e151 100644
--- a/ee/spec/javascripts/fixtures/merge_requests.rb
+++ b/ee/spec/javascripts/fixtures/merge_requests.rb
@@ -33,6 +33,8 @@
     approver_group = create(:approver_group, target: project)
     approver_group.group.add_owner(create(:owner))
 
+    stub_feature_flags(approval_rules: false)
+
     sign_in(admin)
   end
 
diff --git a/ee/spec/models/approval_merge_request_fallback_spec.rb b/ee/spec/models/approval_merge_request_fallback_spec.rb
new file mode 100644
index 0000000000000000000000000000000000000000..f64f2c1554ea160c94fd06fe4c796d81f1a9dff6
--- /dev/null
+++ b/ee/spec/models/approval_merge_request_fallback_spec.rb
@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe ApprovalMergeRequestFallback do
+  using RSpec::Parameterized::TableSyntax
+
+  let(:merge_request) { create(:merge_request, approvals_before_merge: 2) }
+  let(:project) { merge_request.project }
+  subject(:rule) { described_class.new(merge_request) }
+
+  describe '#approvals_required' do
+    where(:merge_request_requirement, :project_requirement, :project_rule_requirement, :expected) do
+      nil | nil | nil | 0
+      10  | 5   | nil | 10
+      2   | 9   | nil | 9
+      2   | 9   | 7   | 7
+      10  | 9   | 7   | 10
+    end
+
+    with_them do
+      before do
+        merge_request.approvals_before_merge = merge_request_requirement
+        project.approvals_before_merge = project_requirement
+        if project_rule_requirement
+          create(:approval_project_rule,
+                 project: project,
+                 approvals_required: project_rule_requirement)
+        end
+      end
+
+      it 'returns the expected value' do
+        expect(rule.approvals_required).to eq(expected)
+      end
+    end
+  end
+
+  describe '#approvals_left' do
+    it 'returns the correct number of approvals left' do
+      create(:approval, merge_request: merge_request)
+
+      expect(rule.approvals_left).to eq(1)
+    end
+  end
+
+  describe '#approved?' do
+    it 'is falsy' do
+      expect(rule.approved?).to be(false)
+    end
+
+    it 'is true if there where enough approvals' do
+      create_list(:approval, 2, merge_request: merge_request)
+
+      expect(rule.approved?).to be(true)
+    end
+  end
+end
diff --git a/ee/spec/models/approval_state_spec.rb b/ee/spec/models/approval_state_spec.rb
index 91424969e156f10371d8617f95d9aefb83ec169a..ff61555ff4ec9aa9dd6dd967641c48a07fe1acc1 100644
--- a/ee/spec/models/approval_state_spec.rb
+++ b/ee/spec/models/approval_state_spec.rb
@@ -10,6 +10,13 @@ def create_rule(additional_params = {})
     create(factory, params)
   end
 
+  def approve_rules(rules)
+    rules_to_approve = rules.select { |rule| rule.approvals_required > 0 }
+    rules_to_approve.each do |rule|
+      create(:approval, merge_request: merge_request, user: rule.users.first)
+    end
+  end
+
   let(:merge_request) { create(:merge_request) }
   let(:project) { merge_request.target_project }
   let(:approver1) { create(:user) }
@@ -130,9 +137,7 @@ def create_rule(additional_params = {})
       shared_examples_for 'when rules are present' do
         context 'when all rules are approved' do
           before do
-            subject.wrapped_approval_rules.each do |rule|
-              create(:approval, merge_request: merge_request, user: rule.users.first)
-            end
+            approve_rules(subject.wrapped_approval_rules)
           end
 
           it 'returns true' do
@@ -154,10 +159,6 @@ def create_rule(additional_params = {})
       shared_examples_for 'checking fallback_approvals_required' do
         before do
           project.update(approvals_before_merge: 1)
-
-          subject.wrapped_approval_rules.each do |rule|
-            allow(rule).to receive(:approved?).and_return(true)
-          end
         end
 
         context 'when it is not met' do
@@ -686,9 +687,7 @@ def create_rules
       shared_examples_for 'when rules are present' do
         context 'when all rules are approved' do
           before do
-            subject.wrapped_approval_rules.each do |rule|
-              create(:approval, merge_request: merge_request, user: rule.users.first)
-            end
+            approve_rules(subject.wrapped_approval_rules)
           end
 
           it 'returns true' do
@@ -710,10 +709,6 @@ def create_rules
       shared_examples_for 'checking fallback_approvals_required' do
         before do
           project.update(approvals_before_merge: 1)
-
-          subject.wrapped_approval_rules.each do |rule|
-            allow(rule).to receive(:approved?).and_return(true)
-          end
         end
 
         context 'when it is not met' do
@@ -737,7 +732,8 @@ def create_rules
 
       context 'when only code owner rules present' do
         before do
-          2.times { create_rule(users: [create(:user)], code_owner: true) }
+          # setting approvals required to 0 since we don't want to block on them now
+          2.times { create_rule(users: [create(:user)], code_owner: true, approvals_required: 0) }
         end
 
         it_behaves_like 'when rules are present'
@@ -752,6 +748,40 @@ def create_rules
 
         it_behaves_like 'when rules are present'
       end
+
+      context 'when a single project rule is present' do
+        before do
+          create(:approval_project_rule, users: [create(:user)], project: project)
+        end
+
+        it_behaves_like 'when rules are present'
+
+        context 'when the project rule is overridden by a fallback but the project does not allow overriding' do
+          before do
+            merge_request.update!(approvals_before_merge: 1)
+            project.update!(disable_overriding_approvers_per_merge_request: true)
+          end
+
+          it_behaves_like 'when rules are present'
+        end
+
+        context 'when the project rule is overridden by a fallback' do
+          before do
+            merge_request.update!(approvals_before_merge: 1)
+          end
+
+          it_behaves_like 'checking fallback_approvals_required'
+        end
+      end
+
+      context 'when a single project rule is present that is overridden in the merge request' do
+        before do
+          create(:approval_project_rule, users: [create(:user)], project: project)
+          merge_request.update!(approvals_before_merge: 1)
+        end
+
+        it_behaves_like 'checking fallback_approvals_required'
+      end
     end
 
     describe '#any_approver_allowed?' do
diff --git a/ee/spec/models/concerns/approval_rule_like_spec.rb b/ee/spec/models/concerns/approval_rule_like_spec.rb
index 44a112f70af798aa40f7041c4b4350ba5792edd5..50ab066336915cdb72e5630b85a8ed0a29bc2256 100644
--- a/ee/spec/models/concerns/approval_rule_like_spec.rb
+++ b/ee/spec/models/concerns/approval_rule_like_spec.rb
@@ -118,4 +118,12 @@
       expect(subject.group_users).to eq([user1])
     end
   end
+
+  context '#rule_type' do
+    it 'returns the correct type' do
+      expect(build(:code_owner_rule).rule_type).to eq(:code_owner)
+      expect(build(:approval_merge_request_rule).rule_type).to eq(:regular)
+      expect(build(:approval_project_rule).rule_type).to eq(:regular)
+    end
+  end
 end
diff --git a/ee/spec/models/project_spec.rb b/ee/spec/models/project_spec.rb
index 4ac039c8e4fc4766a6d261766e53c76288ad429b..f7ade1a579aa09e3320baeb26d902f5eb6bb1116 100644
--- a/ee/spec/models/project_spec.rb
+++ b/ee/spec/models/project_spec.rb
@@ -944,6 +944,58 @@
     end
   end
 
+  describe '#visible_regular_approval_rules' do
+    let(:project) { create(:project) }
+    let!(:approval_rules) { create_list(:approval_project_rule, 2, project: project) }
+
+    before do
+      stub_licensed_features(multiple_approval_rules: true)
+    end
+
+    it 'returns all approval rules' do
+      expect(project.visible_regular_approval_rules).to contain_exactly(*approval_rules)
+    end
+
+    context 'when multiple approval rules is not available' do
+      before do
+        stub_licensed_features(multiple_approval_rules: false)
+      end
+
+      it 'returns the first approval rule' do
+        expect(project.visible_regular_approval_rules).to contain_exactly(approval_rules.first)
+      end
+    end
+  end
+
+  describe '#min_fallback_approvals' do
+    let(:project) { create(:project) }
+
+    it 'returns approvals before merge if there are no rules' do
+      project.approvals_before_merge = 3
+
+      expect(project.min_fallback_approvals).to eq(3)
+    end
+
+    context 'when approval rules are present' do
+      before do
+        create(:approval_project_rule, project: project, approvals_required: 2)
+        create(:approval_project_rule, project: project, approvals_required: 3)
+
+        stub_licensed_features(multiple_approval_rules: true)
+      end
+
+      it 'returns the maximum requirement' do
+        expect(project.min_fallback_approvals).to eq(3)
+      end
+
+      it 'returns the first rule requirement if there is a rule' do
+        stub_licensed_features(multiple_approval_rules: false)
+
+        expect(project.min_fallback_approvals).to eq(2)
+      end
+    end
+  end
+
   shared_examples 'project with disabled services' do
     it 'has some disabled services' do
       stub_const('License::ANY_PLAN_FEATURES', [])
diff --git a/ee/spec/presenters/approval_rule_presenter_spec.rb b/ee/spec/presenters/approval_rule_presenter_spec.rb
index 173a708306a8ef41707b7c04430277e3497e2cf3..87fdb3220e94ea6e41dbdaa4bdcadbd525cecf6a 100644
--- a/ee/spec/presenters/approval_rule_presenter_spec.rb
+++ b/ee/spec/presenters/approval_rule_presenter_spec.rb
@@ -8,10 +8,9 @@
     set(:public_group) { create(:group) }
     set(:private_group) { create(:group, :private) }
     let(:groups) { [public_group, private_group] }
+    subject { described_class.new(rule, current_user: user) }
 
     shared_examples 'filtering private group' do
-      subject { described_class.new(rule, current_user: user) }
-
       context 'when user has no access to private group' do
         it 'excludes private group' do
           expect(subject.groups).to contain_exactly(public_group)
@@ -41,5 +40,13 @@
 
       it_behaves_like 'filtering private group'
     end
+
+    context 'fallback rule' do
+      let(:rule) { ApprovalMergeRequestFallback.new(create(:merge_request)) }
+
+      it 'contains no groups without raising an error' do
+        expect(subject.groups).to be_empty
+      end
+    end
   end
 end
diff --git a/ee/spec/requests/api/merge_request_approvals_spec.rb b/ee/spec/requests/api/merge_request_approvals_spec.rb
index aae11c23dbd4f01a8df5737824921ff37460b053..12be401815155b2ed1707520ada19a75975077c4 100644
--- a/ee/spec/requests/api/merge_request_approvals_spec.rb
+++ b/ee/spec/requests/api/merge_request_approvals_spec.rb
@@ -434,7 +434,10 @@ def approve(extra_params = {})
       expect(response).to have_gitlab_http_status(200)
       expect(json_response['approvals_required']).to eq 2
       expect(json_response['approvals_left']).to eq 2
-      expect(json_response['approval_rules_left']).to eq(['foo'])
+
+      short_approval = { "id" => rule.id, "name" => rule.name, "rule_type" => rule.rule_type.to_s }
+      expect(json_response['approval_rules_left']).to eq([short_approval])
+
       expect(json_response['approved_by']).to be_empty
       expect(json_response['user_can_approve']).to be true
       expect(json_response['user_has_approved']).to be false
diff --git a/locale/gitlab.pot b/locale/gitlab.pot
index ba812afb6d6641bfe12624d214bfc9f77bfcd47c..9ef8b97417bb6b44884babbdaa7c8bd907e4039c 100644
--- a/locale/gitlab.pot
+++ b/locale/gitlab.pot
@@ -982,6 +982,16 @@ msgstr[1] ""
 msgid "ApprovalRuleRemove|You are about to remove the %{name} approver group which has %{nMembers}."
 msgstr ""
 
+msgid "ApprovalRuleSummary|%d member"
+msgid_plural "ApprovalRuleSummary|%d members"
+msgstr[0] ""
+msgstr[1] ""
+
+msgid "ApprovalRuleSummary|%{count} approval required from %{membersCount}"
+msgid_plural "ApprovalRuleSummary|%{count} approvals required from %{membersCount}"
+msgstr[0] ""
+msgstr[1] ""
+
 msgid "ApprovalRule|All members with Developer role or higher and code owners (if any)"
 msgstr ""