diff --git a/contentcuration/contentcuration/frontend/channelEdit/components/edit/ActivityDuration.vue b/contentcuration/contentcuration/frontend/channelEdit/components/edit/ActivityDuration.vue
new file mode 100644
index 0000000000..debdbeadc3
--- /dev/null
+++ b/contentcuration/contentcuration/frontend/channelEdit/components/edit/ActivityDuration.vue
@@ -0,0 +1,188 @@
+<template>
+
+  <VFlex>
+    <VLayout row wrap justify-space-between>
+      <VFlex
+        v-if="audioVideoUpload && selectedDuration === 'exactTime'"
+        class="defaultUpload md2 sm3"
+      >
+        {{ defaultUploadTime }}
+      </VFlex>
+      <VFlex
+        v-else-if="selectedDuration === 'shortActivity' || selectedDuration === 'longActivity'"
+        md3
+        sm3
+      >
+        <VAutocomplete
+          v-model.number="minutes"
+          :step="increments"
+          box
+          :label="$tr('minutesRequired')"
+          :items="availableNumbers"
+        />
+      </VFlex>
+      <VFlex v-else md3 sm3>
+        <VTextField
+          v-model="minutes"
+          type="number"
+          box
+          :min="minRange"
+          :max="maxRange"
+          :label="$tr('minutesRequired')"
+          :rules="minutesRules"
+        />
+      </VFlex>
+    </VLayout>
+    <VLayout row wrap>
+      <VFlex v-if="showRequiredLabel">
+        {{ $tr('notOptionalLabel') }}
+      </VFlex>
+      <VFlex v-else-if="showOptionalLabel">
+        {{ $tr('optionalLabel') }}
+      </VFlex>
+    </VLayout>
+  </VFlex>
+
+</template>
+
+<script>
+
+  import debounce from 'lodash/debounce';
+  import { CompletionDropdownMap, DurationDropdownMap } from 'shared/constants';
+  import {
+    getShortActivityDurationValidators,
+    getLongActivityDurationValidators,
+    getActivityDurationValidators,
+    translateValidator,
+  } from 'shared/utils/validation';
+
+  const SHORT_MIN = 1;
+  const SHORT_MAX = 30;
+  const LONG_MIN = 31;
+  const LONG_MAX = 120;
+  const EXACT_MIN = 1;
+  const EXACT_MAX = 1200;
+  const SHORT_ACTIVITY_RANGE = [5, 10, 15, 20, 25, 30];
+  const LONG_ACTIVITY_RANGE = [40, 50, 60, 70, 80, 90, 100, 110, 120];
+
+  export default {
+    name: 'ActivityDuration',
+    props: {
+      selectedDuration: {
+        type: String,
+        default: '',
+      },
+      selectedCompletion: {
+        type: String,
+        default: '',
+      },
+      value: {
+        type: Number,
+        default: 0,
+      },
+      audioVideoUpload: {
+        type: Boolean,
+        default: false,
+      },
+      duration: {
+        type: Number,
+        default: null,
+      },
+    },
+    data() {
+      return {
+        defaultUploadTime: this.duration || `17:12`,
+      };
+    },
+    computed: {
+      showRequiredLabel() {
+        return (
+          this.selectedDuration !== DurationDropdownMap.EXACT_TIME &&
+          this.selectedCompletion === CompletionDropdownMap.completeDuration
+        );
+      },
+      showOptionalLabel() {
+        return this.selectedDuration !== DurationDropdownMap.EXACT_TIME;
+      },
+      increments() {
+        return this.selectedDuration === DurationDropdownMap.SHORT_ACTIVITY ? 5 : 10;
+      },
+      availableNumbers() {
+        return this.selectedDuration === DurationDropdownMap.SHORT_ACTIVITY
+          ? SHORT_ACTIVITY_RANGE
+          : LONG_ACTIVITY_RANGE;
+      },
+
+      minutes: {
+        get() {
+          if (!this.value) {
+            return '';
+          }
+          return this.convertToMinutes(this.value);
+        },
+        set(value) {
+          this.handleValidateMinutes(value);
+        },
+      },
+      maxRange() {
+        if (this.selectedDuration === DurationDropdownMap.SHORT_ACTIVITY) {
+          return SHORT_MAX;
+        } else if (this.selectedDuration === 'longActivity') {
+          return LONG_MAX;
+        } else {
+          return EXACT_MAX;
+        }
+      },
+      minRange() {
+        if (this.selectedDuration === 'shortActvity') {
+          return SHORT_MIN;
+        } else if (this.selectedDuration === DurationDropdownMap.LONG_ACTIVITY) {
+          return LONG_MIN;
+        } else {
+          return EXACT_MIN;
+        }
+      },
+      minutesRules() {
+        if (this.selectedDuration === DurationDropdownMap.SHORT_ACTIVITY) {
+          return getShortActivityDurationValidators().map(translateValidator);
+        } else if (this.selectedDuration === DurationDropdownMap.LONG_ACTIVITY) {
+          return getLongActivityDurationValidators().map(translateValidator);
+        }
+        return getActivityDurationValidators().map(translateValidator);
+      },
+    },
+    created() {
+      this.handleValidateMinutes = debounce(this.validateMinutes, 500);
+    },
+    methods: {
+      convertToMinutes(seconds) {
+        return Math.floor(seconds / 60);
+      },
+      validateMinutes(value) {
+        if (this.selectedDuration === DurationDropdownMap.EXACT_TIME) {
+          this.$emit('input', value * 60);
+        } else {
+          if (value >= this.minRange && value <= this.maxRange) {
+            this.$emit('input', value * 60);
+          }
+        }
+      },
+    },
+    $trs: {
+      minutesRequired: 'Minutes',
+      optionalLabel:
+        '(Optional) Duration until resource is marked as complete. This value will not be shown to learners.',
+      notOptionalLabel:
+        'Duration until resource is marked as complete. This value will not be shown to learners.',
+    },
+  };
+
+</script>
+<style lang="scss" scoped>
+
+  .defaultUpload {
+    margin: 0.8em;
+    font-size: 1.2em;
+  }
+
+</style>
diff --git a/contentcuration/contentcuration/frontend/channelEdit/components/edit/CompletionOptions.vue b/contentcuration/contentcuration/frontend/channelEdit/components/edit/CompletionOptions.vue
new file mode 100644
index 0000000000..8a1571b454
--- /dev/null
+++ b/contentcuration/contentcuration/frontend/channelEdit/components/edit/CompletionOptions.vue
@@ -0,0 +1,816 @@
+<template>
+
+  <div>
+    <!-- Layout when practice quizzes are enabled -->
+    <VLayout v-if="showCompletionDropdown" xs6 md6>
+      <!-- "Completion" dropdown menu  -->
+      <VFlex xs6 md6 class="pr-2">
+        <VSelect
+          ref="completion"
+          v-model="completionDropdown"
+          box
+          :items="showCorrectCompletionOptions"
+          :label="translateMetadataString('completion')"
+          :required="required"
+          :rules="completionRules"
+          @focus="trackClick('Completion')"
+        />
+      </VFlex>
+      <VFlex>
+        <MasteryCriteriaGoal
+          v-if="showMasteryCriteriaGoalDropdown"
+          ref="mastery_model"
+          v-model="goal"
+          :placeholder="getPlaceholder('mastery_model')"
+          :required="isUnique(mastery_model)"
+          @focus="trackClick('Mastery model')"
+        />
+      </VFlex>
+    </VLayout>
+
+    <!-- Layout when practice quizzes are NOT enabled -->
+    <VLayout v-else xs6 md6>
+      <VFlex xs6 md6 class="pr-2">
+        <MasteryCriteriaGoal
+          v-if="kind === 'exercise'"
+          ref="mastery_model"
+          v-model="goal"
+          :placeholder="getPlaceholder('mastery_model')"
+          :required="isUnique(mastery_model)"
+          @focus="trackClick('Mastery model')"
+        />
+      </VFlex>
+    </VLayout>
+
+    <VLayout>
+      <MasteryCriteriaMofNFields
+        v-if="kind === 'exercise'"
+        ref="mastery_model"
+        v-model="masteryModelItem"
+        :showMofN="showMofN"
+        :mPlaceholder="getPlaceholder('m')"
+        :mRequired="isUnique(m)"
+        :nPlaceholder="getPlaceholder('n')"
+        :nRequired="isUnique(n)"
+        @mFocus="trackClick('Mastery m value')"
+        @nFocus="trackClick('Mastery n value')"
+      />
+    </VLayout>
+
+    <VLayout row wrap>
+      <VFlex xs6 md6 class="pr-2">
+        <VSelect
+          v-if="!hideDurationDropdown"
+          v-model="durationDropdown"
+          box
+          :items="selectableDurationOptions"
+          :label="translateMetadataString('duration')"
+          :required="required"
+          :rules="durationRules"
+          @focus="trackClick('Duration')"
+        />
+      </VFlex>
+
+      <!-- "Activity duration" minutes input -->
+      <VFlex xs6 md6>
+        <ActivityDuration
+          v-if="showActivityDurationInput"
+          v-model="minutes"
+          :selectedDuration="currentDurationDropdown || durationDropdown"
+          :duration="fileDuration"
+          :selectedCompletion="currentCompletionDropdown || completionDropdown"
+          :audioVideoUpload="kind === 'video' || kind === 'audio'"
+        />
+      </VFlex>
+
+      <!-- Reference hint -->
+      <VFlex v-if="showReferenceHint" style="margin-bottom: 8px" xs6 md6>
+        {{ $tr('referenceHint') }}
+      </VFlex>
+    </VLayout>
+  </div>
+
+</template>
+
+<script>
+
+  import ActivityDuration from './ActivityDuration.vue';
+  import MasteryCriteriaGoal from './MasteryCriteriaGoal';
+  import MasteryCriteriaMofNFields from './MasteryCriteriaMofNFields';
+  import {
+    CompletionCriteriaModels,
+    ContentModalities,
+    CompletionDropdownMap,
+    DurationDropdownMap,
+  } from 'shared/constants';
+  import { MasteryModelsNames } from 'shared/leUtils/MasteryModels';
+  import { ContentKindsNames } from 'shared/leUtils/ContentKinds';
+  import {
+    getCompletionValidators,
+    getDurationValidators,
+    translateValidator,
+  } from 'shared/utils/validation';
+  import { metadataStrings, metadataTranslationMixin } from 'shared/mixins';
+
+  const DEFAULT_SHORT_ACTIVITY = 600;
+  const DEFAULT_LONG_ACTIVITY = 3000;
+  const SHORT_LONG_ACTIVITY_MIDPOINT = 1860;
+  const nonUniqueValue = {};
+  nonUniqueValue.toString = () => '';
+
+  const SuggestedDurationTypesMap = {
+    APPROX_TIME: 'approx_time',
+    TIME: 'time',
+  };
+
+  export default {
+    name: 'CompletionOptions',
+    components: {
+      ActivityDuration,
+      MasteryCriteriaMofNFields,
+      MasteryCriteriaGoal,
+    },
+    mixins: [metadataStrings, metadataTranslationMixin],
+    props: {
+      kind: {
+        type: String,
+        required: false,
+      },
+      fileDuration: {
+        type: Number,
+        default: null,
+      },
+      required: {
+        type: Boolean,
+        default: true,
+      },
+      practiceQuizzesAllowed: {
+        type: Boolean,
+        default: false,
+      },
+      value: {
+        type: Object,
+        required: false,
+      },
+    },
+    data() {
+      return {
+        disabledReference: ['reference'],
+        // required state because we need to know the durationDropdown before it is set in backend
+        currentDurationDropdown: null,
+        // required state because we need to know the completion to determine durationDropdown model
+        currentCompletionDropdown: null,
+        mastery_model: null,
+        m: 3,
+        n: 5,
+      };
+    },
+    computed: {
+      showMasteryCriteriaGoalDropdown() {
+        if (this.kind === ContentKindsNames.EXERCISE) {
+          if (this.value.modality === ContentModalities.QUIZ) {
+            //this ensures that anytime the completion dropdown is practice quiz
+            return false;
+          }
+          return true;
+        }
+        return false;
+      },
+      showCompletionDropdown() {
+        /*
+          This condition can be removed once practice quizzes are fully implemented in 0.16
+        */
+        return !(this.kind === ContentKindsNames.EXERCISE && !this.practiceQuizzesAllowed);
+      },
+      audioVideoResource() {
+        return this.kind === ContentKindsNames.AUDIO || this.kind === ContentKindsNames.VIDEO;
+      },
+      hideDurationDropdown() {
+        // named "hide" instead of "show" because "show" is the default behavior
+        return (
+          this.currentCompletionDropdown === CompletionDropdownMap.reference ||
+          (this.value.model === CompletionCriteriaModels.REFERENCE &&
+            !this.currentCompletionDropdown &&
+            this.audioVideoResource) ||
+          //should be hidden if model is reference and we're getting this from the BE
+          this.currentCompletionDropdown === CompletionDropdownMap.determinedByResource
+        );
+      },
+      showReferenceHint() {
+        /*
+          The reference hint should be shown only when "Reference" is selected
+        */
+        if (this.kind === ContentKindsNames.H5P || this.kind === ContentKindsNames.HTML5) {
+          if (this.currentCompletionDropdown === CompletionDropdownMap.determinedByResource) {
+            return false;
+          }
+          if (
+            this.value.model === CompletionCriteriaModels.REFERENCE &&
+            this.currentCompletionDropdown === CompletionDropdownMap.completeDuration
+          ) {
+            return true;
+          }
+        }
+        return (
+          (this.durationDropdown === DurationDropdownMap.REFERENCE &&
+            this.currentCompletionDropdown === CompletionDropdownMap.allContent) ||
+          this.currentCompletionDropdown === CompletionDropdownMap.reference ||
+          (this.value.model === CompletionCriteriaModels.REFERENCE &&
+            this.currentCompletionDropdown !== CompletionDropdownMap.completeDuration)
+        );
+      },
+      showActivityDurationInput() {
+        /* The `ActivityDuration` component should visible when:
+          - Long activity, short activity, or exact time are chosen if it is not an AV resource
+          - Long activity or short activity are chosen if it is an AV resource
+        */
+        const switchingFromReferenceBetweenAllContentViewedAndCompleteDuration =
+          this.value.suggested_duration === null || this.value.suggested_duration_type === null;
+
+        if (!this.audioVideoResource) {
+          return !(
+            this.value.model === CompletionCriteriaModels.REFERENCE ||
+            switchingFromReferenceBetweenAllContentViewedAndCompleteDuration
+          );
+        }
+        return this.audioVideoResource && this.value.model !== CompletionCriteriaModels.REFERENCE;
+      },
+      completionDropdown: {
+        get() {
+          if (this.audioVideoResource) {
+            if (this.value.model === CompletionCriteriaModels.REFERENCE) {
+              return CompletionDropdownMap.reference;
+            }
+            return CompletionDropdownMap.completeDuration;
+          }
+
+          if (this.kind === ContentKindsNames.DOCUMENT) {
+            if (!this.value['model']) {
+              return CompletionDropdownMap.allContent;
+            } else {
+              if (
+                this.value.model === CompletionCriteriaModels.PAGES ||
+                this.value.model === CompletionCriteriaModels.REFERENCE
+              ) {
+                return CompletionDropdownMap.allContent;
+              }
+              return CompletionDropdownMap.completeDuration;
+            }
+          }
+
+          if (this.kind === ContentKindsNames.HTML5) {
+            if (!this.value['model']) {
+              return CompletionDropdownMap.completeDuration;
+            }
+            return this.value.model;
+          }
+
+          if (this.kind === ContentKindsNames.H5P) {
+            if (!this.value['model']) {
+              return CompletionDropdownMap.determinedByResource;
+            }
+            return CompletionDropdownMap.completeDuration;
+          }
+
+          if (this.kind === ContentKindsNames.EXERCISE) {
+            // if the practice quiz flag is set, return "practice quiz"
+            if (this.practiceQuizzesAllowed && this.value.modality === ContentModalities.QUIZ) {
+              return CompletionDropdownMap.practiceQuiz;
+            }
+            return CompletionDropdownMap.goal;
+          }
+
+          return '';
+        },
+        set(value) {
+          let update = {};
+          this.currentCompletionDropdown = value;
+
+          // FOR AUDIO/VIDEO
+          if (value === CompletionDropdownMap.reference) {
+            update.suggested_duration_type = this.value.suggested_duration_type;
+            update.completion_criteria = {
+              model: CompletionCriteriaModels.REFERENCE,
+              threshold: null,
+            };
+          }
+
+          // FOR DOCUMENTS
+          if (this.kind === ContentKindsNames.DOCUMENT) {
+            if (value === CompletionDropdownMap.allContent) {
+              update.suggested_duration_type = this.value.suggested_duration_type;
+              update.suggested_duration = this.value.suggested_duration;
+              update.completion_criteria = {
+                model: CompletionCriteriaModels.PAGES,
+                threshold: '100%',
+              };
+            } else {
+              update.suggested_duration_type = this.value.suggested_duration_type;
+              update.suggested_duration = this.value.suggested_duration;
+              if (
+                this.durationDropdown === DurationDropdownMap.LONG_ACTIVITY ||
+                this.durationDropdown === DurationDropdownMap.SHORT_ACTIVITY
+              ) {
+                update.completion_criteria = {
+                  model: CompletionCriteriaModels.APPROX_TIME,
+                  threshold: this.value.suggested_duration || 0,
+                };
+              } else if (this.durationDropdown === DurationDropdownMap.EXACT_TIME) {
+                update.completion_criteria = {
+                  model: CompletionCriteriaModels.TIME,
+                  threshold: this.value.suggested_duration || 0,
+                };
+              } else {
+                // default state
+                update.completion_criteria = {
+                  model: this.value.model,
+                  threshold: this.value.threshold,
+                };
+              }
+            }
+          }
+
+          // FOR EXERCISES
+          if (this.kind === ContentKindsNames.EXERCISE) {
+            if (value === CompletionDropdownMap.practiceQuiz) {
+              update.modality = ContentModalities.QUIZ;
+              update.completion_criteria = {
+                model: this.value.model,
+                threshold: this.value.threshold,
+              };
+            } else {
+              update.modality = null;
+              update.completion_criteria = {
+                model: this.value.model,
+                threshold: this.value.threshold,
+              };
+            }
+          }
+          this.handleInput(update);
+        },
+      },
+      goal: {
+        get() {
+          if (this.value.threshold) {
+            return { mastery_model: this.value.threshold.mastery_model };
+          }
+          return { mastery_model: this.mastery_model };
+        },
+        set(threshold) {
+          let update = {};
+          if (threshold.mastery_model === MasteryModelsNames.M_OF_N) {
+            update.completion_criteria = {
+              model: CompletionCriteriaModels.MASTERY,
+              threshold: {
+                mastery_model: threshold.mastery_model,
+                m: this.value.threshold.m || this.m,
+                n: this.value.threshold.n || this.n,
+              },
+            };
+          } else {
+            update.completion_criteria = {
+              model: CompletionCriteriaModels.MASTERY,
+              threshold: {
+                mastery_model: threshold.mastery_model,
+                m: null,
+                n: null,
+              },
+            };
+          }
+          this.m = this.value.threshold.m || this.m;
+          this.n = this.value.threshold.n || this.n;
+          this.handleInput(update);
+        },
+      },
+      showMofN() {
+        if (this.kind === ContentKindsNames.EXERCISE) {
+          if (this.value.modality === ContentModalities.QUIZ) {
+            return false;
+          }
+          if (this.value.threshold) {
+            const defaultStateWhenSwitchingFromGoalToPracticeQuiz =
+              this.value.threshold.mastery_model === MasteryModelsNames.M_OF_N &&
+              this.currentCompletionDropdown === null;
+            if (
+              this.currentCompletionDropdown === CompletionDropdownMap.goal &&
+              this.value.threshold.mastery_model === MasteryModelsNames.M_OF_N
+            ) {
+              return true;
+            }
+            if (defaultStateWhenSwitchingFromGoalToPracticeQuiz) {
+              return true;
+            }
+          }
+        }
+        return false;
+      },
+      masteryModelItem: {
+        get() {
+          if (this.value.threshold.mastery_model !== MasteryModelsNames.M_OF_N) {
+            return {
+              m: this.value.threshold.m,
+              n: this.value.threshold.n,
+            };
+          }
+          return {
+            m: this.value.threshold.m ? this.value.threshold.m : this.m,
+            n: this.value.threshold.n ? this.value.threshold.n : this.n,
+          };
+        },
+        set(threshold) {
+          this.m = threshold.m;
+          this.n = threshold.n;
+
+          let update = {};
+          update.completion_criteria = {
+            model: CompletionCriteriaModels.MASTERY,
+            threshold: {
+              mastery_model: this.value.threshold.mastery_model,
+              m: threshold.m,
+              n: threshold.n,
+            },
+          };
+          this.handleInput(update);
+        },
+      },
+      isLongActivity() {
+        return (
+          this.value.suggested_duration > SHORT_LONG_ACTIVITY_MIDPOINT &&
+          this.value.suggested_duration_type === SuggestedDurationTypesMap.APPROX_TIME
+        );
+      },
+      isShortActivity() {
+        return (
+          this.value.suggested_duration <= SHORT_LONG_ACTIVITY_MIDPOINT &&
+          this.value.suggested_duration_type === SuggestedDurationTypesMap.APPROX_TIME
+        );
+      },
+      isExactTime() {
+        return this.value.suggested_duration_type === SuggestedDurationTypesMap.TIME;
+      },
+      isSwitchingFromCompleteDurationToAllContent() {
+        return (
+          this.completionDropdown === CompletionDropdownMap.completeDuration &&
+          this.currentCompletionDropdown === CompletionDropdownMap.allContent
+        );
+      },
+      isSwitchingFromAllContentToCompleteDuration() {
+        return (
+          this.completionDropdown === CompletionDropdownMap.allContent &&
+          this.currentCompletionDropdown === CompletionDropdownMap.completeDuration
+        );
+      },
+      requiresAudioVideoDefault() {
+        return this.audioVideoResource && !this.value.model;
+      },
+      completionDropdownIsCompleteDuration() {
+        return (
+          (this.completionDropdown === null &&
+            this.currentCompletionDropdown === CompletionDropdownMap.completeDuration) ||
+          (this.completionDropdown === CompletionDropdownMap.completeDuration &&
+            this.currentCompletionDropdown === null) ||
+          (this.completionDropdown === CompletionDropdownMap.completeDuration &&
+            this.currentCompletionDropdown === CompletionDropdownMap.completeDuration) ||
+          this.currentCompletionDropdown === CompletionDropdownMap.completeDuration
+        );
+      },
+      completionDropdownIsAllContentViewed() {
+        return (
+          (this.completionDropdown === null &&
+            this.currentCompletionDropdown === CompletionDropdownMap.nt &&
+            this.currentCompletionDropdown === null) ||
+          (this.completionDropdown === CompletionDropdownMap.allContent &&
+            this.currentCompletionDropdown === CompletionDropdownMap.allContent)
+        );
+      },
+      durationDropdown: {
+        get() {
+          const defaultStateForAudioVideo =
+            this.value.suggested_duration === null &&
+            this.value.suggested_duration_type === null &&
+            this.audioVideoResource;
+          if (
+            this.value.model === CompletionCriteriaModels.REFERENCE ||
+            (this.currentCompletionDropdown === CompletionDropdownMap.completeDuration &&
+              this.currentDurationDropdown === DurationDropdownMap.REFERENCE)
+          ) {
+            return DurationDropdownMap.REFERENCE;
+          } else if (this.value.model === CompletionCriteriaModels.PAGES) {
+            if (this.isLongActivity) {
+              return DurationDropdownMap.LONG_ACTIVITY;
+            }
+            if (this.isShortActivity) {
+              return DurationDropdownMap.SHORT_ACTIVITY;
+            }
+            if (this.isExactTime) {
+              return DurationDropdownMap.EXACT_TIME;
+            }
+          } else if (
+            this.value.model === CompletionCriteriaModels.TIME ||
+            defaultStateForAudioVideo
+          ) {
+            return DurationDropdownMap.EXACT_TIME;
+          } else {
+            if (this.isLongActivity) {
+              return DurationDropdownMap.LONG_ACTIVITY;
+            }
+            if (this.isShortActivity) {
+              return DurationDropdownMap.SHORT_ACTIVITY;
+            }
+            if (this.isExactTime) {
+              return DurationDropdownMap.EXACT_TIME;
+            }
+          }
+          return '';
+        },
+        set(duration) {
+          const update = {};
+          this.currentDurationDropdown = duration;
+
+          if (duration === DurationDropdownMap.REFERENCE) {
+            update.suggested_duration_type = null;
+            update.completion_criteria = {
+              model: CompletionCriteriaModels.REFERENCE,
+              threshold: null,
+            };
+          } else if (
+            this.isSwitchingFromCompleteDurationToAllContent ||
+            this.completionDropdownIsAllContentViewed
+          ) {
+            if (duration === DurationDropdownMap.EXACT_TIME) {
+              update.suggested_duration_type = SuggestedDurationTypesMap.TIME;
+              update.suggested_duration = this.value.suggested_duration || 60;
+            }
+            if (duration === DurationDropdownMap.SHORT_ACTIVITY) {
+              update.suggested_duration_type = SuggestedDurationTypesMap.APPROX_TIME;
+              const roundedValue = Math.round(this.value.suggested_duration / 300) * 300;
+              if (roundedValue > SHORT_LONG_ACTIVITY_MIDPOINT || roundedValue <= 0) {
+                update.suggested_duration = DEFAULT_SHORT_ACTIVITY;
+              } else {
+                update.suggested_duration = roundedValue;
+              }
+            }
+            if (duration === DurationDropdownMap.LONG_ACTIVITY) {
+              update.suggested_duration_type = SuggestedDurationTypesMap.APPROX_TIME;
+              const roundedValue = Math.round(this.value.suggested_duration / 600) * 600;
+              if (roundedValue < SHORT_LONG_ACTIVITY_MIDPOINT || roundedValue > 7200) {
+                update.suggested_duration = DEFAULT_LONG_ACTIVITY;
+              } else {
+                update.suggested_duration = roundedValue;
+              }
+            }
+            update.completion_criteria = {
+              model: CompletionCriteriaModels.PAGES,
+              threshold: '100%',
+            };
+          } else if (
+            this.isSwitchingFromAllContentToCompleteDuration ||
+            this.requiresAudioVideoDefault ||
+            this.completionDropdownIsCompleteDuration
+          ) {
+            if (duration === DurationDropdownMap.SHORT_ACTIVITY) {
+              update.suggested_duration_type = SuggestedDurationTypesMap.APPROX_TIME;
+              const roundedValue = Math.round(this.value.suggested_duration / 300) * 300;
+              if (roundedValue > SHORT_LONG_ACTIVITY_MIDPOINT || roundedValue <= 0) {
+                update.suggested_duration = DEFAULT_SHORT_ACTIVITY;
+              } else {
+                update.suggested_duration = roundedValue;
+              }
+              update.completion_criteria = {
+                model: CompletionCriteriaModels.APPROX_TIME,
+                threshold: update.suggested_duration,
+              };
+            }
+            if (duration === DurationDropdownMap.LONG_ACTIVITY) {
+              update.suggested_duration_type = SuggestedDurationTypesMap.APPROX_TIME;
+              const roundedValue = Math.round(this.value.suggested_duration / 600) * 600;
+              if (roundedValue < SHORT_LONG_ACTIVITY_MIDPOINT || roundedValue > 7200) {
+                update.suggested_duration = DEFAULT_LONG_ACTIVITY;
+              } else {
+                update.suggested_duration = roundedValue;
+              }
+              update.completion_criteria = {
+                model: CompletionCriteriaModels.APPROX_TIME,
+                threshold: update.suggested_duration,
+              };
+            }
+            if (duration === DurationDropdownMap.EXACT_TIME) {
+              update.suggested_duration_type = SuggestedDurationTypesMap.TIME;
+              update.suggested_duration = this.value.suggested_duration || 60;
+              update.completion_criteria = {
+                model: CompletionCriteriaModels.TIME,
+                threshold: update.suggested_duration,
+              };
+            }
+          }
+
+          if (this.value.model === CompletionCriteriaModels.MASTERY) {
+            if (duration === DurationDropdownMap.SHORT_ACTIVITY) {
+              update.suggested_duration_type = SuggestedDurationTypesMap.APPROX_TIME;
+              const roundedValue = Math.round(this.value.suggested_duration / 300) * 300;
+              if (roundedValue > SHORT_LONG_ACTIVITY_MIDPOINT || roundedValue <= 0) {
+                update.suggested_duration = DEFAULT_SHORT_ACTIVITY;
+              } else {
+                update.suggested_duration = roundedValue;
+              }
+              update.completion_criteria = {
+                model: this.value.model,
+                threshold: this.value.threshold,
+              };
+            }
+            if (duration === DurationDropdownMap.LONG_ACTIVITY) {
+              update.suggested_duration_type = SuggestedDurationTypesMap.APPROX_TIME;
+              const roundedValue = Math.round(this.value.suggested_duration / 600) * 600;
+              if (roundedValue < SHORT_LONG_ACTIVITY_MIDPOINT || roundedValue > 7200) {
+                update.suggested_duration = DEFAULT_LONG_ACTIVITY;
+              } else {
+                update.suggested_duration = roundedValue;
+              }
+              update.completion_criteria = {
+                model: this.value.model,
+                threshold: this.value.threshold,
+              };
+            }
+            if (duration === DurationDropdownMap.EXACT_TIME) {
+              update.suggested_duration_type = SuggestedDurationTypesMap.TIME;
+              update.suggested_duration = this.value.suggested_duration || 60;
+              update.completion_criteria = {
+                model: this.value.model,
+                threshold: this.value.threshold,
+              };
+            }
+          }
+          this.handleInput(update);
+        },
+      },
+      minutes: {
+        get() {
+          return this.value.suggested_duration;
+        },
+        set(minutes) {
+          if (
+            this.value.model === CompletionCriteriaModels.PAGES ||
+            this.value.model === CompletionCriteriaModels.MASTERY
+          ) {
+            this.handleInput({
+              suggested_duration: minutes,
+              completion_criteria: {
+                model: this.value.model,
+                threshold: this.value.threshold,
+              },
+            });
+          } else {
+            this.handleInput({
+              suggested_duration: minutes,
+              completion_criteria: {
+                model: this.value.model,
+                threshold: minutes,
+              },
+            });
+          }
+        },
+      },
+      showCorrectCompletionOptions() {
+        const CompletionOptionsDropdownMap = {
+          document: [CompletionDropdownMap.allContent, CompletionDropdownMap.completeDuration],
+          exercise: [CompletionDropdownMap.goal, CompletionDropdownMap.practiceQuiz],
+          html5: [
+            CompletionDropdownMap.completeDuration,
+            CompletionDropdownMap.determinedByResource,
+          ],
+          h5p: [CompletionDropdownMap.determinedByResource, CompletionDropdownMap.completeDuration],
+          audio: [CompletionDropdownMap.completeDuration, CompletionDropdownMap.reference],
+          video: [CompletionDropdownMap.completeDuration, CompletionDropdownMap.reference],
+        };
+
+        return CompletionOptionsDropdownMap[this.kind].map(model => ({
+          text: this.$tr(model),
+          value: CompletionDropdownMap[model],
+        }));
+      },
+      allPossibleDurationOptions() {
+        //this is used because of this Vuetify issue for dropdowns with multiple values: https://github.com/vuetifyjs/vuetify/issues/11529
+        return [
+          {
+            text: this.$tr(DurationDropdownMap.EXACT_TIME),
+            value: CompletionCriteriaModels.TIME,
+            id: 'exactTime',
+          },
+          {
+            text: this.translateMetadataString(DurationDropdownMap.SHORT_ACTIVITY),
+            value: CompletionCriteriaModels.APPROX_TIME,
+            id: 'shortActivity',
+          },
+          {
+            text: this.translateMetadataString(DurationDropdownMap.LONG_ACTIVITY),
+            value: CompletionCriteriaModels.APPROX_TIME,
+            id: 'longActivity',
+          },
+          {
+            text: this.translateMetadataString('readReference'),
+            value: CompletionCriteriaModels.REFERENCE,
+            id: 'reference',
+          },
+        ];
+      },
+      /**
+       * When the duration dropdown is for audio, video, or documents, if "Complete duration"
+       * is chosen, then "Reference" cannot be selected
+       */
+      selectableDurationOptions() {
+        if (
+          (this.kind === ContentKindsNames.DOCUMENT &&
+            this.currentCompletionDropdown === CompletionDropdownMap.completeDuration) ||
+          this.audioVideoResource
+        ) {
+          return this.allPossibleDurationOptions.map(model => ({
+            value: model.id,
+            text: model.text,
+            disabled: this.disabledReference.includes(model.value),
+          }));
+        } else if (this.kind === ContentKindsNames.EXERCISE) {
+          return this.allPossibleDurationOptions
+            .filter(model => model.value !== CompletionCriteriaModels.REFERENCE)
+            .map(model => ({
+              value: model.id,
+              text: model.text,
+            }));
+        } else {
+          return this.allPossibleDurationOptions.map(model => ({
+            value: model.id,
+            text: model.text,
+          }));
+        }
+      },
+      completionRules() {
+        return this.required ? getCompletionValidators().map(translateValidator) : [];
+      },
+      durationRules() {
+        const defaultStateForDocument = this.currentCompletionDropdown === null;
+        const allContentViewedIsChosenInCompletionDropdown =
+          this.currentCompletionDropdown === CompletionDropdownMap.allContent ||
+          (this.value.model === CompletionCriteriaModels.PAGES &&
+            this.currentCompletionDropdown === CompletionDropdownMap.allContent);
+
+        if (defaultStateForDocument || allContentViewedIsChosenInCompletionDropdown) {
+          return [];
+        }
+        return getDurationValidators().map(translateValidator);
+      },
+    },
+    methods: {
+      trackClick(label) {
+        this.$analytics.trackClick('channel_editor_modal_details', label);
+      },
+      handleInput({
+        completion_criteria,
+        suggested_duration,
+        suggested_duration_type,
+        modality,
+      } = {}) {
+        const data = {
+          completion_criteria,
+          suggested_duration,
+          suggested_duration_type,
+          modality,
+        };
+
+        if (!completion_criteria) {
+          data['completion_criteria'] = this.value['completion_criteria'];
+        }
+        if (modality === undefined) {
+          data['modality'] = this.value['modality'];
+        }
+        if (suggested_duration === undefined) {
+          data['suggested_duration'] = this.value['suggested_duration'];
+        }
+        if (suggested_duration_type === undefined) {
+          data['suggested_duration_type'] = this.value['suggested_duration_type'];
+        }
+        this.$emit('input', data);
+      },
+      isUnique(value) {
+        return value !== nonUniqueValue;
+      },
+      getPlaceholder(field) {
+        return this.isUnique(this[field]) ? '' : '---';
+      },
+    },
+    $trs: {
+      /* eslint-disable kolibri/vue-no-unused-translations */
+      allContent: 'All content viewed',
+      completeDuration: 'Complete duration',
+      determinedByResource: 'Determined by resource',
+      goal: 'Practice until goal is met',
+      practiceQuiz: 'Practice quiz',
+      /* eslint-enable */
+      exactTime: 'Exact time to complete',
+      reference: 'Reference',
+      referenceHint:
+        'Progress will not be tracked on reference material unless learners mark it as complete',
+    },
+  };
+
+</script>
+<style lang="scss">
+</style>
diff --git a/contentcuration/contentcuration/frontend/channelEdit/components/edit/DetailsTabView.vue b/contentcuration/contentcuration/frontend/channelEdit/components/edit/DetailsTabView.vue
index 3fd74720d6..327d6faec3 100644
--- a/contentcuration/contentcuration/frontend/channelEdit/components/edit/DetailsTabView.vue
+++ b/contentcuration/contentcuration/frontend/channelEdit/components/edit/DetailsTabView.vue
@@ -54,11 +54,7 @@
                 @focus="trackClick('Description')"
               />
             </VFlex>
-            <VFlex
-              xs12
-              md6
-              :class="{ 'pl-2': $vuetify.breakpoint.mdAndUp }"
-            >
+            <VFlex xs12 md6 :class="{ 'pl-2': $vuetify.breakpoint.mdAndUp }">
               <!-- Learning activity -->
               <LearningActivityOptions
                 id="learning_activities"
@@ -114,29 +110,12 @@
         </VFlex>
       </VLayout>
 
-      <!-- Assessment options -->
+      <!-- Completion section for exercises -->
       <VLayout v-if="allExercises" row wrap class="section">
         <VFlex xs12>
           <h1 class="subheading">
-            {{ $tr('assessmentHeader') }}
+            {{ $tr('assessmentOptionsLabel') }}
           </h1>
-
-          <!-- Mastery -->
-          <MasteryDropdown
-            v-if="extra_fields"
-            ref="mastery_model"
-            v-model="masteryModelItem"
-            :placeholder="getPlaceholder('mastery_model')"
-            :required="isUnique(mastery_model)"
-            :mPlaceholder="getPlaceholder('m')"
-            :mRequired="isUnique(m)"
-            :nPlaceholder="getPlaceholder('n')"
-            :nRequired="isUnique(n)"
-            @focus="trackClick('Mastery model')"
-            @mFocus="trackClick('Mastery m value')"
-            @nFocus="trackClick('Mastery n value')"
-          />
-
           <!-- Randomize question order -->
           <Checkbox
             ref="randomize"
@@ -144,13 +123,30 @@
             :label="$tr('randomizeQuestionLabel')"
             :indeterminate="!isUnique(randomizeOrder)"
           />
+        </VFlex>
+      </VLayout>
 
-          <!-- Feature flag: Channel quizzes -->
-          <Checkbox
-            v-if="allowChannelQuizzes"
-            v-model="channelQuiz"
-            :label="$tr('channelQuizzesLabel')"
-            :indeterminate="!oneSelected"
+      <!-- Completion section for all resources -->
+      <VLayout row wrap class="section">
+        <VFlex xs12>
+          <h1 class="subheading">
+            {{ $tr('completionLabel') }}
+          </h1>
+          <!-- Checkbox for "Allow learners to mark complete" -->
+          <VFlex md6 class="pb-2">
+            <Checkbox
+              v-model="learnerManaged"
+              color="primary"
+              :label="$tr('learnersCanMarkComplete')"
+              style="margin-top: 0px; padding-top: 0px"
+            />
+          </VFlex>
+          <CompletionOptions
+            v-model="completionAndDuration"
+            :kind="firstNode.kind"
+            :fileDuration="fileDuration"
+            :required="!isDocument"
+            :practiceQuizzesAllowed="allowChannelQuizzes"
           />
         </VFlex>
       </VLayout>
@@ -162,7 +158,7 @@
             {{ $tr('thumbnailHeader') }}
           </h1>
           <!-- Thumbnail -->
-          <div style="width:250px;">
+          <div style="width: 250px">
             <ContentNodeThumbnail
               v-model="thumbnail"
               :nodeId="firstNode.id"
@@ -239,8 +235,6 @@
               />
             </p>
 
-            <!-- Need to break up v-model to properly show placeholder -->
-
             <!-- Author -->
             <VCombobox
               ref="author"
@@ -253,7 +247,7 @@
               box
               :placeholder="getPlaceholder('author')"
               :value="author && author.toString()"
-              @input.native="e => author = e.srcElement.value"
+              @input.native="(e) => (author = e.srcElement.value)"
               @input="author = $event"
               @focus="trackClick('Author')"
             >
@@ -274,7 +268,7 @@
               autoSelectFirst
               box
               :value="provider && provider.toString()"
-              @input.native="e => provider = e.srcElement.value"
+              @input.native="(e) => (provider = e.srcElement.value)"
               @input="provider = $event"
               @focus="trackClick('Provider')"
             >
@@ -295,7 +289,7 @@
               :placeholder="getPlaceholder('aggregator')"
               box
               :value="aggregator && aggregator.toString()"
-              @input.native="e => aggregator = e.srcElement.value"
+              @input.native="(e) => (aggregator = e.srcElement.value)"
               @input="aggregator = $event"
               @focus="trackClick('Aggregator')"
             >
@@ -332,7 +326,7 @@
               :readonly="disableAuthEdits"
               box
               :value="copyright_holder && copyright_holder.toString()"
-              @input.native="e => copyright_holder = e.srcElement.value"
+              @input.native="(e) => (copyright_holder = e.srcElement.value)"
               @input="copyright_holder = $event"
               @focus="trackClick('Copyright holder')"
             />
@@ -375,6 +369,7 @@
   import ResourcesNeededOptions from './ResourcesNeededOptions.vue';
   import LearningActivityOptions from './LearningActivityOptions.vue';
   import CategoryOptions from './CategoryOptions.vue';
+  import CompletionOptions from './CompletionOptions.vue';
 
   import {
     getTitleValidators,
@@ -385,11 +380,10 @@
   import LanguageDropdown from 'shared/views/LanguageDropdown';
   import HelpTooltip from 'shared/views/HelpTooltip';
   import LicenseDropdown from 'shared/views/LicenseDropdown';
-  import MasteryDropdown from 'shared/views/MasteryDropdown';
   import VisibilityDropdown from 'shared/views/VisibilityDropdown';
   import Checkbox from 'shared/views/form/Checkbox';
   import { ContentKindsNames } from 'shared/leUtils/ContentKinds';
-  import { NEW_OBJECT, FeatureFlagKeys, ContentModalities } from 'shared/constants';
+  import { NEW_OBJECT, FeatureFlagKeys } from 'shared/constants';
   import { validate as validateCompletionCriteria } from 'shared/leUtils/CompletionCriteria';
   import { constantsTranslationMixin, metadataTranslationMixin } from 'shared/mixins';
 
@@ -435,7 +429,9 @@
    * - `learner_needs` (resources needed)
    * - `accessibility_labels` (accessibility options)
    * - `learning_activities` (learning activities)
+   * - `categories` (categories)
    */
+
   function generateNestedNodesGetterSetter(key) {
     return {
       get() {
@@ -458,7 +454,6 @@
       LanguageDropdown,
       HelpTooltip,
       LicenseDropdown,
-      MasteryDropdown,
       VisibilityDropdown,
       FileUpload,
       SubtitlesList,
@@ -469,6 +464,7 @@
       ResourcesNeededOptions,
       LearningActivityOptions,
       CategoryOptions,
+      CompletionOptions,
     },
     mixins: [constantsTranslationMixin, metadataTranslationMixin],
     props: {
@@ -552,27 +548,7 @@
       resourcesNeeded: generateNestedNodesGetterSetter('learner_needs'),
       contentLearningActivities: generateNestedNodesGetterSetter('learning_activities'),
       categories: generateNestedNodesGetterSetter('categories'),
-      mastery_model() {
-        return this.getExtraFieldsValueFromNodes('mastery_model');
-      },
-      m() {
-        return this.getExtraFieldsValueFromNodes('m');
-      },
-      n() {
-        return this.getExtraFieldsValueFromNodes('n');
-      },
-      masteryModelItem: {
-        get() {
-          return {
-            mastery_model: this.mastery_model,
-            m: this.m,
-            n: this.n,
-          };
-        },
-        set(value) {
-          this.updateExtraFields(value);
-        },
-      },
+      learnerManaged: generateGetterSetter('learner_managed'),
       license() {
         return this.getValueFromNodes('license');
       },
@@ -590,9 +566,6 @@
           this.update(value);
         },
       },
-      extra_fields() {
-        return this.getValueFromNodes('extra_fields');
-      },
       thumbnail: {
         get() {
           return this.nodeFiles.find(f => f.preset.thumbnail);
@@ -602,34 +575,37 @@
         },
       },
       thumbnailEncoding: generateGetterSetter('thumbnail_encoding'),
-      channelQuiz: {
+      completionAndDuration: {
         get() {
-          const options = this.getExtraFieldsValueFromNodes('options') || {};
-          return options.modality === ContentModalities.QUIZ;
-        },
-        set(val) {
-          const options = { modality: val ? ContentModalities.QUIZ : null };
-          this.updateExtraFields({ options });
-        },
-      },
-      // TODO remove eslint disable when `completionCriteria` is utilized
-      /* eslint-disable-next-line kolibri/vue-no-unused-properties */
-      completionCriteria: {
-        get() {
-          const options = this.getExtraFieldsValueFromNodes('options') || {};
-          return options.completion_criteria || {};
+          const { completion_criteria, modality } =
+            this.getExtraFieldsValueFromNodes('options') || {};
+          const suggested_duration_type = this.getExtraFieldsValueFromNodes(
+            'suggested_duration_type'
+          );
+          const suggested_duration = this.getValueFromNodes('suggested_duration');
+          return {
+            suggested_duration,
+            suggested_duration_type,
+            modality,
+            ...(completion_criteria || {}),
+          };
         },
-        set(completion_criteria) {
-          // TODO Remove validation if unnecessary after implementing `completionCriteria`
-          if (validateCompletionCriteria(completion_criteria)) {
+        set({ completion_criteria, suggested_duration, suggested_duration_type, modality }) {
+          if (validateCompletionCriteria(completion_criteria, this.firstNode.kind)) {
             const options = { completion_criteria };
             this.updateExtraFields({ options });
           } else {
             console.warn('Invalid completion criteria', [...validateCompletionCriteria.errors]);
           }
+          const options = { completion_criteria, modality };
+          if (modality) {
+            options.modality = modality;
+          }
+          this.updateExtraFields({ options });
+          this.updateExtraFields({ suggested_duration_type });
+          this.update({ suggested_duration });
         },
       },
-
       /* COMPUTED PROPS */
       disableAuthEdits() {
         return this.nodes.some(node => node.freeze_authoring_data);
@@ -665,6 +641,15 @@
       nodeFiles() {
         return (this.firstNode && this.getContentNodeFiles(this.firstNode.id)) || [];
       },
+      fileDuration() {
+        if (this.firstNode.kind === 'audio' || this.firstNode.kind === 'video') {
+          return this.nodeFiles.filter(
+            file => file.file_format === 'mp4' || file.file_format === 'mp3'
+          )[0].duration;
+        } else {
+          return null;
+        }
+      },
       videoSelected() {
         return this.oneSelected && this.firstNode.kind === 'video';
       },
@@ -674,6 +659,9 @@
       allowChannelQuizzes() {
         return this.$store.getters.hasFeatureEnabled(FeatureFlagKeys.channel_quizzes);
       },
+      isDocument() {
+        return this.firstNode.kind === 'document';
+      },
     },
     watch: {
       nodes: {
@@ -800,7 +788,6 @@
       basicInfoHeader: 'Basic information',
       audienceHeader: 'Audience',
       sourceHeader: 'Source',
-      assessmentHeader: 'Assessment options',
       thumbnailHeader: 'Thumbnail',
       titleLabel: 'Title',
       languageHelpText: 'Leave blank to use the folder language',
@@ -819,8 +806,10 @@
       descriptionLabel: 'Description',
       tagsLabel: 'Tags',
       noTagsFoundText: 'No results found for "{text}". Press \'Enter\' key to create a new tag',
+      assessmentOptionsLabel: 'Assessment options',
       randomizeQuestionLabel: 'Randomize question order for learners',
-      channelQuizzesLabel: 'Allow as a channel quiz',
+      completionLabel: 'Completion',
+      learnersCanMarkComplete: 'Allow learners to mark as complete',
     },
   };
 
diff --git a/contentcuration/contentcuration/frontend/channelEdit/components/edit/MasteryCriteriaGoal.vue b/contentcuration/contentcuration/frontend/channelEdit/components/edit/MasteryCriteriaGoal.vue
new file mode 100644
index 0000000000..f56ba17306
--- /dev/null
+++ b/contentcuration/contentcuration/frontend/channelEdit/components/edit/MasteryCriteriaGoal.vue
@@ -0,0 +1,139 @@
+<template>
+
+  <VFlex>
+    <VLayout>
+      <VFlex>
+        <VSelect
+          ref="masteryModel"
+          v-model="masteryModel"
+          :items="masteryCriteria"
+          :label="$tr('labelText')"
+          color="primary"
+          box
+          :placeholder="placeholder"
+          :required="required"
+          :readonly="readonly"
+          :rules="masteryRules"
+          menu-props="offsetY"
+          class="mb-2"
+          @focus="$emit('focus')"
+        />
+      </VFlex>
+    </VLayout>
+  </VFlex>
+
+</template>
+
+<script>
+
+  import { getMasteryModelValidators, translateValidator } from '../../../shared/utils/validation';
+  import MasteryModels, { MasteryModelsList } from 'shared/leUtils/MasteryModels';
+  import { constantsTranslationMixin } from 'shared/mixins';
+
+  export default {
+    name: 'MasteryCriteriaGoal',
+    mixins: [constantsTranslationMixin],
+    props: {
+      value: {
+        type: Object,
+        required: false,
+        validator: function(value) {
+          return (
+            !value ||
+            !value.mastery_model ||
+            !value.mastery_model.toString() ||
+            MasteryModels.has(value.mastery_model)
+          );
+        },
+      },
+      placeholder: {
+        type: String,
+      },
+      required: {
+        type: Boolean,
+        default: true,
+      },
+      readonly: {
+        type: Boolean,
+        default: false,
+      },
+    },
+    computed: {
+      masteryModel: {
+        get() {
+          return this.value && this.value.mastery_model;
+        },
+        set(mastery_model) {
+          this.handleInput({ mastery_model });
+        },
+      },
+      masteryCriteria() {
+        return MasteryModelsList.map(model => ({
+          text: this.translateConstant(model),
+          value: model,
+        }));
+      },
+      masteryRules() {
+        return this.required ? getMasteryModelValidators().map(translateValidator) : [];
+      },
+    },
+    methods: {
+      handleInput(newValue) {
+        let data = {
+          ...this.value,
+          ...newValue,
+        };
+        this.$emit('input', data);
+      },
+    },
+    $trs: {
+      labelText: 'Goal',
+    },
+  };
+
+</script>
+
+
+<style lang="less" scoped>
+
+  .v-autocomplete {
+    display: inline-block;
+    width: 150px;
+  }
+
+  .mastery-field {
+    width: 50px;
+  }
+
+  .out-of {
+    padding-top: 20px;
+    font-size: 18pt;
+    color: var(--v-grey-darken1);
+    text-align: center;
+  }
+
+  .mastery-table {
+    padding: 15px;
+    .mastery-row {
+      padding: 5px;
+      &:nth-child(odd) {
+        background-color: var(--v-greyBackground-base);
+      }
+      .mastery-label {
+        padding-right: 15px;
+        font-weight: bold;
+      }
+    }
+  }
+  /deep/ a {
+    text-decoration: none !important;
+    &:hover {
+      color: var(--v-blue-darken-1);
+    }
+  }
+
+  /deep/ .v-list__tile {
+    width: 100%;
+  }
+
+</style>
diff --git a/contentcuration/contentcuration/frontend/shared/views/MasteryDropdown.vue b/contentcuration/contentcuration/frontend/channelEdit/components/edit/MasteryCriteriaMofNFields.vue
similarity index 63%
rename from contentcuration/contentcuration/frontend/shared/views/MasteryDropdown.vue
rename to contentcuration/contentcuration/frontend/channelEdit/components/edit/MasteryCriteriaMofNFields.vue
index 4178418e2d..9ba5a5cf2e 100644
--- a/contentcuration/contentcuration/frontend/shared/views/MasteryDropdown.vue
+++ b/contentcuration/contentcuration/frontend/channelEdit/components/edit/MasteryCriteriaMofNFields.vue
@@ -1,36 +1,6 @@
 <template>
 
-  <VFlex xs12 sm11 md10 lg9 xl8>
-    <VSelect
-      ref="masteryModel"
-      v-model="masteryModel"
-      :items="masteryCriteria"
-      :label="$tr('labelText')"
-      color="primary"
-      box
-      :placeholder="placeholder"
-      :required="required"
-      :readonly="readonly"
-      :disabled="disabled"
-      :rules="masteryRules"
-      menu-props="offsetY"
-      class="mb-2"
-      @focus="$emit('focus')"
-    >
-      <template #append-outer>
-        <InfoModal :header="$tr('exerciseHeader')" :items="masteryCriteria">
-          <p>{{ $tr('exerciseDescripiton') }}</p>
-          <p>{{ $tr('masteryDescripiton') }}</p>
-          <template #header="{ item }">
-            {{ translateConstant(item.value) }}
-          </template>
-          <template #description="{ item }">
-            {{ translateConstant(item.value + '_description') }}
-          </template>
-        </InfoModal>
-      </template>
-    </VSelect>
-
+  <VFlex>
     <VLayout v-if="showMofN" class="mofn-options" row>
       <VFlex xs6>
         <VTextField
@@ -44,7 +14,6 @@
           :placeholder="mPlaceholder"
           :readonly="readonly"
           :rules="mRules"
-          :disabled="disabled"
           @keypress="isIntegerInput($event)"
           @paste="isIntegerPaste($event)"
           @focus="$emit('mFocus')"
@@ -53,7 +22,7 @@
       <VFlex xs1 justifyCenter class="out-of">
         /
       </VFlex>
-      <VFlex xs5>
+      <VFlex xs6>
         <VTextField
           ref="nValue"
           v-model="nValue"
@@ -65,7 +34,6 @@
           :readonly="readonly"
           :placeholder="nPlaceholder"
           :rules="nRules"
-          :disabled="disabled"
           @keypress="isIntegerInput($event)"
           @paste="isIntegerPaste($event)"
           @focus="$emit('nFocus')"
@@ -79,23 +47,15 @@
 <script>
 
   import {
-    getMasteryModelValidators,
     getMasteryModelMValidators,
     getMasteryModelNValidators,
     translateValidator,
-  } from '../utils/validation';
-  import MasteryModels, {
-    MasteryModelsList,
-    MasteryModelsNames,
-  } from 'shared/leUtils/MasteryModels';
-  import InfoModal from 'shared/views/InfoModal.vue';
+  } from '../../../shared/utils/validation';
+  import MasteryModels from 'shared/leUtils/MasteryModels'; // MasteryModelsNames, // MasteryModelsList,
   import { constantsTranslationMixin } from 'shared/mixins';
 
   export default {
-    name: 'MasteryDropdown',
-    components: {
-      InfoModal,
-    },
+    name: 'MasteryCriteriaMofNFields',
     mixins: [constantsTranslationMixin],
     props: {
       value: {
@@ -110,18 +70,11 @@
           );
         },
       },
-      placeholder: {
-        type: String,
-      },
-      required: {
-        type: Boolean,
-        default: true,
-      },
-      readonly: {
+      showMofN: {
         type: Boolean,
         default: false,
       },
-      disabled: {
+      readonly: {
         type: Boolean,
         default: false,
       },
@@ -141,14 +94,6 @@
       },
     },
     computed: {
-      masteryModel: {
-        get() {
-          return this.value && this.value.mastery_model;
-        },
-        set(mastery_model) {
-          this.handleInput({ mastery_model });
-        },
-      },
       mValue: {
         get() {
           return this.value && this.value.m;
@@ -169,18 +114,6 @@
           this.handleInput(value < this.mValue ? { m: value, n: value } : { n: value });
         },
       },
-      masteryCriteria() {
-        return MasteryModelsList.map(model => ({
-          text: this.translateConstant(model),
-          value: model,
-        }));
-      },
-      showMofN() {
-        return this.masteryModel === MasteryModelsNames.M_OF_N;
-      },
-      masteryRules() {
-        return this.required ? getMasteryModelValidators().map(translateValidator) : [];
-      },
       mRules() {
         return this.mRequired
           ? getMasteryModelMValidators(this.nValue).map(translateValidator)
@@ -223,12 +156,6 @@
       },
     },
     $trs: {
-      labelText: 'Mastery criteria',
-      exerciseHeader: 'About exercises',
-      exerciseDescripiton:
-        'Exercises contain a set of interactive questions that a learner can engage with in Kolibri. Learners receive instant feedback for each answer (correct or incorrect). Kolibri will display available questions in an exercise until the learner achieves mastery.',
-      masteryDescripiton:
-        'Kolibri marks an exercise as "completed" when the mastery criteria is met. Here are the different types of mastery criteria for an exercise:',
       mHint: 'Correct answers needed',
       nHint: 'Recent answers',
     },
diff --git a/contentcuration/contentcuration/frontend/channelEdit/vuex/contentNode/actions.js b/contentcuration/contentcuration/frontend/channelEdit/vuex/contentNode/actions.js
index c32ef53fc3..068e809898 100644
--- a/contentcuration/contentcuration/frontend/channelEdit/vuex/contentNode/actions.js
+++ b/contentcuration/contentcuration/frontend/channelEdit/vuex/contentNode/actions.js
@@ -181,6 +181,7 @@ export function createContentNode(context, { parent, kind, ...payload }) {
     learner_needs: {},
     learning_activities: {},
     categories: {},
+    suggested_duration: 0,
     ...payload,
   };
 
@@ -218,6 +219,7 @@ function generateContentNodeData({
   learner_needs = NOVALUE,
   learning_activities = NOVALUE,
   categories = NOVALUE,
+  suggested_duration = NOVALUE,
 } = {}) {
   const contentNodeData = {};
   if (title !== NOVALUE) {
@@ -271,7 +273,9 @@ function generateContentNodeData({
   if (categories !== NOVALUE) {
     contentNodeData.categories = categories;
   }
-
+  if (suggested_duration !== NOVALUE) {
+    contentNodeData.suggested_duration = suggested_duration;
+  }
   if (extra_fields !== NOVALUE) {
     contentNodeData.extra_fields = contentNodeData.extra_fields || {};
     if (extra_fields.mastery_model) {
@@ -289,6 +293,9 @@ function generateContentNodeData({
     if (extra_fields.options) {
       contentNodeData.extra_fields.options = extra_fields.options;
     }
+    if (extra_fields.suggested_duration_type) {
+      contentNodeData.extra_fields.suggested_duration_type = extra_fields.suggested_duration_type;
+    }
   }
   if (prerequisite !== NOVALUE) {
     contentNodeData.prerequisite = prerequisite;
diff --git a/contentcuration/contentcuration/frontend/shared/constants.js b/contentcuration/contentcuration/frontend/shared/constants.js
index 100c8a579d..fbc0b23b1f 100644
--- a/contentcuration/contentcuration/frontend/shared/constants.js
+++ b/contentcuration/contentcuration/frontend/shared/constants.js
@@ -1,5 +1,6 @@
 import invert from 'lodash/invert';
 import Subjects from 'kolibri-constants/labels/Subjects';
+import CompletionCriteria from 'kolibri-constants/CompletionCriteria';
 import featureFlagsSchema from 'static/feature_flags.json';
 
 export { default as LearningActivities } from 'kolibri-constants/labels/LearningActivities';
@@ -11,6 +12,7 @@ export { default as ContentLevels } from 'kolibri-constants/labels/Levels';
 export { default as ResourcesNeededTypes } from 'kolibri-constants/labels/Needs';
 
 export const CategoriesLookup = invert(Subjects);
+export const CompletionCriteriaLookup = invert(CompletionCriteria);
 
 export const ContentDefaults = {
   author: 'author',
@@ -166,6 +168,14 @@ export const ValidationErrors = {
   NO_VALID_PRIMARY_FILES: 'NO_VALID_PRIMARY_FILES',
   INVALID_COMPLETION_CRITERIA_MODEL: 'INVALID_COMPLETION_CRITERIA_MODEL',
   LEARNING_ACTIVITY_REQUIRED: 'LEARNING_ACTIVITY_REQUIRED',
+  DURATION_REQUIRED: 'DURATION_REQUIRED',
+  ACTIVITY_DURATION_REQUIRED: 'ACTIVITY_DURATION_REQUIRED',
+  ACTIVITY_DURATION_MIN_FOR_SHORT_ACTIVITY: 'ACTIVITY_DURATION_MIN_FOR_SHORT_ACTIVITY',
+  ACTIVITY_DURATION_MAX_FOR_SHORT_ACTIVITY: 'ACTIVITY_DURATION_MAX_FOR_SHORT_ACTIVITY',
+  ACTIVITY_DURATION_MIN_FOR_LONG_ACTIVITY: 'ACTIVITY_DURATION_MIN_FOR_LONG_ACTIVITY',
+  ACTIVITY_DURATION_MAX_FOR_LONG_ACTIVITY: 'ACTIVITY_DURATION_MAX_FOR_LONG_ACTIVITY',
+  ACTIVITY_DURATION_MIN_REQUIREMENT: 'ACTIVITY_DURATION_MIN_REQUIREMENT',
+  ACTIVITY_DURATION_TOO_LONG: 'ACTIVITY_DURATION_TOO_LONG',
   ...fileErrors,
 };
 
@@ -190,3 +200,19 @@ export const AccessibilityCategoriesMap = {
   exercise: ['ALT_TEXT'],
   html5: ['ALT_TEXT', 'HIGH_CONTRAST'],
 };
+
+export const CompletionDropdownMap = {
+  allContent: 'allContent',
+  completeDuration: 'completeDuration',
+  determinedByResource: 'determinedByResource',
+  goal: 'goal',
+  practiceQuiz: 'practiceQuiz',
+  reference: 'reference',
+};
+
+export const DurationDropdownMap = {
+  EXACT_TIME: 'exactTime',
+  SHORT_ACTIVITY: 'shortActivity',
+  LONG_ACTIVITY: 'longActivity',
+  REFERENCE: 'reference',
+};
diff --git a/contentcuration/contentcuration/frontend/shared/translator.js b/contentcuration/contentcuration/frontend/shared/translator.js
index 5188bc5f9c..5cf1f5b50f 100644
--- a/contentcuration/contentcuration/frontend/shared/translator.js
+++ b/contentcuration/contentcuration/frontend/shared/translator.js
@@ -15,6 +15,15 @@ const MESSAGES = {
   masteryModelNWholeNumber: 'Must be a whole number',
   confirmLogout: 'Changes you made may not be saved. Are you sure you want to leave this page?',
   learningActivityRequired: 'Learning activity is required',
+  durationRequired: 'Duration is required',
+  activityDurationRequired: 'This field is required',
+  shortActivityGteOne: 'Short activity must be greater than or equal to 1',
+  shortActivityLteThirty: 'Short activity must be less than or equal to 30',
+  longActivityGtThirty: 'Long activity must be greater than 30',
+  longActivityLteOneTwenty: 'Long activity must be less than or equal to 120',
+  activityDurationTimeMinRequirement: 'Time must be greater than or equal to 1',
+  activityDurationTooLongWarning:
+    'Please make sure this is the amount of time you want learners to spend on this resource to complete it',
 };
 
 export default createTranslator('sharedVue', MESSAGES);
diff --git a/contentcuration/contentcuration/frontend/shared/utils/validation.js b/contentcuration/contentcuration/frontend/shared/utils/validation.js
index 8ae07297e1..d253314a7a 100644
--- a/contentcuration/contentcuration/frontend/shared/utils/validation.js
+++ b/contentcuration/contentcuration/frontend/shared/utils/validation.js
@@ -113,6 +113,24 @@ function _getErrorMsg(error) {
     [ValidationErrors.MASTERY_MODEL_N_WHOLE_NUMBER]: translator.$tr('masteryModelNWholeNumber'),
     [ValidationErrors.MASTERY_MODEL_N_GT_ZERO]: translator.$tr('masteryModelNGtZero'),
     [ValidationErrors.LEARNING_ACTIVITY_REQUIRED]: translator.$tr('learningActivityRequired'),
+    [ValidationErrors.DURATION_REQUIRED]: translator.$tr('durationRequired'),
+    [ValidationErrors.ACTIVITY_DURATION_REQUIRED]: translator.$tr('activityDurationRequired'),
+    [ValidationErrors.ACTIVITY_DURATION_MIN_FOR_SHORT_ACTIVITY]: translator.$tr(
+      'shortActivityGteOne'
+    ),
+    [ValidationErrors.ACTIVITY_DURATION_MAX_FOR_SHORT_ACTIVITY]: translator.$tr(
+      'shortActivityLteThirty'
+    ),
+    [ValidationErrors.ACTIVITY_DURATION_MIN_FOR_LONG_ACTIVITY]: translator.$tr(
+      'longActivityGtThirty'
+    ),
+    [ValidationErrors.ACTIVITY_DURATION_MAX_FOR_LONG_ACTIVITY]: translator.$tr(
+      'longActivityLteOneTwenty'
+    ),
+    [ValidationErrors.ACTIVITY_DURATION_MIN_REQUIREMENT]: translator.$tr(
+      'activityDurationTimeMinRequirement'
+    ),
+    [ValidationErrors.ACTIVITY_DURATION_TOO_LONG]: translator.$tr('activityDurationTooLongWarning'),
   };
 
   return messages[error];
@@ -143,6 +161,14 @@ export function getLearningActivityValidators() {
   return [value => Boolean(value.length) || ValidationErrors.LEARNING_ACTIVITY_REQUIRED];
 }
 
+export function getCompletionValidators() {
+  return [value => Boolean(value) || ValidationErrors.COMPLETION_REQUIRED];
+}
+
+export function getDurationValidators() {
+  return [value => Boolean(value.length) || ValidationErrors.DURATION_REQUIRED];
+}
+
 export function getLicenseDescriptionValidators() {
   return [value => Boolean(value && value.trim()) || ValidationErrors.LICENSE_DESCRIPTION_REQUIRED];
 }
@@ -168,6 +194,30 @@ export function getMasteryModelNValidators() {
   ];
 }
 
+export function getShortActivityDurationValidators() {
+  return [
+    v => v !== '' || ValidationErrors.ACTIVITY_DURATION_REQUIRED,
+    v => v >= 1 || ValidationErrors.ACTIVITY_DURATION_MIN_FOR_SHORT_ACTIVITY,
+    v => v <= 30 || ValidationErrors.ACTIVITY_DURATION_MAX_FOR_SHORT_ACTIVITY,
+  ];
+}
+
+export function getLongActivityDurationValidators() {
+  return [
+    v => v !== '' || ValidationErrors.ACTIVITY_DURATION_REQUIRED,
+    v => v > 30 || ValidationErrors.ACTIVITY_DURATION_MIN_FOR_LONG_ACTIVITY,
+    v => v <= 120 || ValidationErrors.ACTIVITY_DURATION_MAX_FOR_LONG_ACTIVITY,
+  ];
+}
+
+export function getActivityDurationValidators() {
+  return [
+    v => v !== '' || ValidationErrors.ACTIVITY_DURATION_REQUIRED,
+    v => v >= 1 || ValidationErrors.ACTIVITY_DURATION_MIN_REQUIREMENT,
+    v => v <= 1200 || ValidationErrors.ACTIVITY_DURATION_TOO_LONG,
+  ];
+}
+
 // Node validation
 // These functions return an array of error codes
 export function getNodeTitleErrors(node) {
diff --git a/contentcuration/contentcuration/frontend/shared/views/__tests__/masteryDropdown.spec.js b/contentcuration/contentcuration/frontend/shared/views/__tests__/masteryDropdown.spec.js
deleted file mode 100644
index 697dbbb90d..0000000000
--- a/contentcuration/contentcuration/frontend/shared/views/__tests__/masteryDropdown.spec.js
+++ /dev/null
@@ -1,214 +0,0 @@
-import { mount } from '@vue/test-utils';
-import MasteryDropdown from '../MasteryDropdown.vue';
-import TestForm from './TestForm.vue';
-import { constantStrings } from 'shared/mixins';
-import MasteryModels from 'shared/leUtils/MasteryModels';
-
-document.body.setAttribute('data-app', true); // Vuetify prints a warning without this
-
-function makeWrapper() {
-  return mount(TestForm, {
-    slots: {
-      testComponent: MasteryDropdown,
-    },
-  });
-}
-
-describe('masteryDropdown', () => {
-  let formWrapper;
-  let wrapper;
-  let modelInput;
-  let mInput;
-  let nInput;
-
-  beforeEach(() => {
-    formWrapper = makeWrapper();
-    wrapper = formWrapper.find(MasteryDropdown);
-    wrapper.setProps({ value: { mastery_model: 'm_of_n' } });
-    modelInput = wrapper.find({ ref: 'masteryModel' }).find('input');
-    wrapper.vm.$nextTick(() => {
-      mInput = wrapper.find({ ref: 'mValue' }).find('input');
-      nInput = wrapper.find({ ref: 'nValue' }).find('input');
-    });
-  });
-
-  describe('on load', () => {
-    MasteryModels.forEach(model => {
-      it(`${model} mastery option should be an option to select`, () => {
-        expect(wrapper.find('.v-list').text()).toContain(constantStrings.$tr(model));
-      });
-    });
-    it('should render according to masteryModel prop', () => {
-      function test(model) {
-        wrapper.setProps({ value: { mastery_model: model } });
-        expect(wrapper.vm.$refs.masteryModel.value).toEqual(model);
-        expect(wrapper.find({ ref: 'mValue' }).exists()).toBe(model === 'm_of_n');
-        expect(wrapper.find({ ref: 'nValue' }).exists()).toBe(model === 'm_of_n');
-      }
-      MasteryModels.forEach(test);
-    });
-    it('should render correct mValue and nValue props', () => {
-      wrapper.setProps({ value: { mastery_model: 'm_of_n', m: 10, n: 20 } });
-      expect(wrapper.vm.$refs.mValue.value).toEqual(10);
-      expect(wrapper.vm.$refs.nValue.value).toEqual(20);
-    });
-  });
-  describe('props', () => {
-    beforeEach(() => {});
-    it('setting readonly should prevent any edits', () => {
-      wrapper.setProps({ readonly: true });
-      wrapper.vm.$nextTick(() => {
-        expect(modelInput.attributes('readonly')).toEqual('readonly');
-        expect(mInput.attributes('readonly')).toEqual('readonly');
-        expect(nInput.attributes('readonly')).toEqual('readonly');
-      });
-    });
-    it('setting required to false should make fields not required (required by default)', () => {
-      expect(modelInput.attributes('required')).toEqual('required');
-      expect(mInput.attributes('required')).toEqual('required');
-      expect(nInput.attributes('required')).toEqual('required');
-
-      wrapper.setProps({ required: false, mRequired: false, nRequired: false });
-      wrapper.vm.$nextTick(() => {
-        expect(modelInput.attributes('required')).toBeFalsy();
-        expect(mInput.attributes('required')).toBeFalsy();
-        expect(nInput.attributes('required')).toBeFalsy();
-      });
-    });
-    it('setting disabled should make fields disabled', () => {
-      expect(modelInput.attributes('disabled')).toBeFalsy();
-      expect(mInput.attributes('disabled')).toBeFalsy();
-      expect(nInput.attributes('disabled')).toBeFalsy();
-
-      wrapper.setProps({ disabled: true });
-      wrapper.vm.$nextTick(() => {
-        expect(modelInput.attributes('disabled')).toEqual('disabled');
-        expect(mInput.attributes('disabled')).toEqual('disabled');
-        expect(nInput.attributes('disabled')).toEqual('disabled');
-      });
-    });
-  });
-  describe('emitted events', () => {
-    it('input should be emitted when masteryModel is updated', () => {
-      expect(wrapper.emitted('input')).toBeFalsy();
-      modelInput.setValue('do_all');
-      expect(wrapper.emitted('input')).toBeTruthy();
-      expect(wrapper.emitted('input')[0][0].mastery_model).toEqual('do_all');
-    });
-    it('input should be emitted when mValue is updated', () => {
-      expect(wrapper.emitted('input')).toBeFalsy();
-      mInput.setValue(10);
-      expect(wrapper.emitted('input')).toBeTruthy();
-      expect(wrapper.emitted('input')[0][0].m).toEqual(10);
-    });
-    it('input should be emitted when mValue is updated', () => {
-      expect(wrapper.emitted('input')).toBeFalsy();
-      nInput.setValue(10);
-      expect(wrapper.emitted('input')).toBeTruthy();
-      expect(wrapper.emitted('input')[0][0].n).toEqual(10);
-    });
-  });
-  describe('validation', () => {
-    it('should flag empty required mastery models', () => {
-      wrapper.setProps({ value: { mastery_model: null } });
-      formWrapper.vm.validate();
-      expect(
-        wrapper
-          .find({ ref: 'masteryModel' })
-          .find('.error--text')
-          .exists()
-      ).toBe(true);
-      wrapper.setProps({ required: false });
-      formWrapper.vm.validate();
-      expect(
-        wrapper
-          .find({ ref: 'masteryModel' })
-          .find('.error--text')
-          .exists()
-      ).toBe(false);
-    });
-    it('should flag empty n and m values', () => {
-      formWrapper.vm.validate();
-      expect(
-        wrapper
-          .find({ ref: 'mValue' })
-          .find('.error--text')
-          .exists()
-      ).toBe(true);
-      expect(
-        wrapper
-          .find({ ref: 'nValue' })
-          .find('.error--text')
-          .exists()
-      ).toBe(true);
-      wrapper.setProps({ mRequired: false, nRequired: false });
-      formWrapper.vm.validate();
-      expect(
-        wrapper
-          .find({ ref: 'mValue' })
-          .find('.error--text')
-          .exists()
-      ).toBe(false);
-      expect(
-        wrapper
-          .find({ ref: 'nValue' })
-          .find('.error--text')
-          .exists()
-      ).toBe(false);
-    });
-    it('should flag if m is not a whole number', () => {
-      wrapper.setProps({ value: { mastery_model: 'm_of_n', m: 0.1231, n: 10 } });
-      formWrapper.vm.validate();
-      expect(
-        wrapper
-          .find({ ref: 'mValue' })
-          .find('.error--text')
-          .exists()
-      ).toBe(true);
-      wrapper.setProps({ value: { mastery_model: 'm_of_n', m: 1, n: 10 } });
-      formWrapper.vm.validate();
-      expect(
-        wrapper
-          .find({ ref: 'mValue' })
-          .find('.error--text')
-          .exists()
-      ).toBe(false);
-    });
-    it('should flag if m < 1', () => {
-      wrapper.setProps({ value: { mastery_model: 'm_of_n', m: 0, n: 10 } });
-      formWrapper.vm.validate();
-      expect(
-        wrapper
-          .find({ ref: 'mValue' })
-          .find('.error--text')
-          .exists()
-      ).toBe(true);
-      wrapper.setProps({ value: { mastery_model: 'm_of_n', m: 1, n: 10 } });
-      formWrapper.vm.validate();
-      expect(
-        wrapper
-          .find({ ref: 'mValue' })
-          .find('.error--text')
-          .exists()
-      ).toBe(false);
-    });
-    it('should flag if m > n', () => {
-      wrapper.setProps({ value: { mastery_model: 'm_of_n', m: 2, n: 1 } });
-      formWrapper.vm.validate();
-      expect(
-        wrapper
-          .find({ ref: 'mValue' })
-          .find('.error--text')
-          .exists()
-      ).toBe(true);
-      wrapper.setProps({ value: { mastery_model: 'm_of_n', m: 2, n: 2 } });
-      formWrapper.vm.validate();
-      expect(
-        wrapper
-          .find({ ref: 'mValue' })
-          .find('.error--text')
-          .exists()
-      ).toBe(false);
-    });
-  });
-});
diff --git a/contentcuration/contentcuration/viewsets/contentnode.py b/contentcuration/contentcuration/viewsets/contentnode.py
index 5fd3fe3091..761fea1410 100644
--- a/contentcuration/contentcuration/viewsets/contentnode.py
+++ b/contentcuration/contentcuration/viewsets/contentnode.py
@@ -284,6 +284,7 @@ class ExtraFieldsOptionsSerializer(JSONFieldDictSerializer):
 class ExtraFieldsSerializer(JSONFieldDictSerializer):
     randomize = BooleanField()
     options = ExtraFieldsOptionsSerializer(required=False)
+    suggested_duration_type = ChoiceField(choices=[completion_criteria.TIME, completion_criteria.APPROX_TIME], allow_null=True, required=False)
 
 
 class TagField(DotPathValueMixin, DictField):