diff --git a/src/common-components/question-chain/question-chain.vue b/src/common-components/question-chain/question-chain.vue
index dee5d1f32..6f52d8e70 100644
--- a/src/common-components/question-chain/question-chain.vue
+++ b/src/common-components/question-chain/question-chain.vue
@@ -90,7 +90,7 @@ export default {
                     "buttonId": "Driver-Front-1-1|answer|DD11132|Yes"
                 }
             */
-            const isQuestionChainComplete = this.getQuestionChainAnswerIfComplete(returnedAnswer.checkValue);
+            const isQuestionChainComplete = this.getQuestionChainAnswerIfComplete(returnedAnswer.value);
 
             if (isQuestionChainComplete) {
                 this.$emit("update:modelValue", isQuestionChainComplete);
diff --git a/src/constants/endpoints.js b/src/constants/endpoints.js
index 9cf0b6856..d0e05919b 100644
--- a/src/constants/endpoints.js
+++ b/src/constants/endpoints.js
@@ -63,8 +63,8 @@ const endpoints = {
     url: "/parts/api/v1/parts/capability-questions",
     method: "GET"
   },
-  ApplyCapabilityAnswerToPart: {
-    url: "/parts/api/v1/parts/apply-capability-answer-to-part",
+  GetPartFromCapabilityAnswer: {
+    url: "/parts/api/v1/parts/part-from-capability-answer",
     method: "POST"
   },
   SaveOrder: {
diff --git a/src/layouts/capability-questions/capability-questions.vue b/src/layouts/capability-questions/capability-questions.vue
index ea51194e8..be43f0db2 100644
--- a/src/layouts/capability-questions/capability-questions.vue
+++ b/src/layouts/capability-questions/capability-questions.vue
@@ -1,38 +1,24 @@
 <template>
-    <Form
-      @submit="onSubmit"
-      @invalid-submit="onInvalidSubmit"
-      ref="theForm"
-      v-slot="{ meta }"
-    >
+    <Form @submit="onSubmit" @invalid-submit="onInvalidSubmit" ref="theForm" v-slot="{ meta }">
         <div class="page-container-grouped-styles capability-questions">
-            <loadingModal ref="loadingModal"/>
+            <loadingModal ref="loadingModal" />
             <funnelHeader cmsWidgetName="FunnelHeaderWidget" />
             <vehicleBanner cmsWidgetName="VehicleBannerWidget" :displayGenericVehicleImage=false />
             <funnelSubHeader cmsWidgetName="FunnelSubHeaderWidget" />
             <div class="fade-on-route-transition sub-container make-tall">
-                <alert
-                    ref="alertFewMoreQuestions"
-                    class="my-5"
-                    alertClass="alert-warning"
-                    :manualHeadline="AlertFewMoreQuestionsHeader"
-                    :manualCopy="AlertFewMoreQuestionsCopy"
-                    v-bind:isDismissible="false"
-                />
-                <questionChain
-                    ref="questionChain"
-                    v-model="selectedAnswer"    
-                    :questionData="capabilityQuestionsData"
-                    :partIndex="i"
-                    validationRules="questions-required"
-                />
-                <funnel-footer
-                    ref="funnelFooter"
-                    cmsWidgetName="FunnelFooterWidget"
-                    :isForwardActionDisabled="!meta.valid"
-                    @back-clicked="backButtonAction"
-                    @ForwardClicked="forwardButtonAction"
-                />
+                <alert ref="alertFewMoreQuestions" class="my-5" alertClass="alert-warning"
+                    :manualHeadline="AlertFewMoreQuestionsHeader" :manualCopy="AlertFewMoreQuestionsCopy"
+                    v-bind:isDismissible="false" />
+                <div v-for="(part, i) in capabilityQuestionsData" :key="part.key">
+                    <questionChain ref="questionChain" :keyString="part.key"
+                        v-model="selectedAnswers[part.glassLocation + '-' + part.glassName]"
+                        :questionData="part.capabilityQuestions" :partIndex="i"
+                        v-if="showThisPartQuestionChain(part, i)"
+                        validationRules="questions-required" />
+                </div>
+                <funnel-footer ref="funnelFooter" cmsWidgetName="FunnelFooterWidget"
+                    :isForwardActionDisabled="!meta.valid" @back-clicked="backButtonAction"
+                    @ForwardClicked="forwardButtonAction" />
             </div>
         </div>
     </Form>
@@ -76,7 +62,7 @@ export default {
                 resultKey: "cmsContent",
                 promise: cmsContentPromise,
             },
-         ];
+        ];
 
         const resultMap = await settleAllPromises(promiseResultMap);
 
@@ -88,19 +74,20 @@ export default {
     data() {
         return {
             selectedAnswer: [],
-            // TODO This shouldn't be an object with property `partQuestions`
-            capabilityQuestionsData: {
-                partQuestions: store.getters.pageData(fmgPageValues.CAPABILITY_QUESTIONS).capabilityQuestions
-            }
+            capabilityQuestionsData: store.getters.pageData(fmgPageValues.CAPABILITY_QUESTIONS).partsOrQuestions,
+            selectedAnswers: {},
+            currentQuestionChainIndex: 0,
+            newAnswersArray: [],
+            foundDuplicateQuestions: [],
         };
     },
     computed: {
         AlertFewMoreQuestionsHeader() {
-			return this.getCmsContent("AdditionalPartsQuestionsAlert", "HeadlineText");
-		},
+            return this.getCmsContent("AdditionalPartsQuestionsAlert", "HeadlineText");
+        },
         AlertFewMoreQuestionsCopy() {
-			return this.getCmsContent("AdditionalPartsQuestionsAlert", "BodyText");
-		},
+            return this.getCmsContent("AdditionalPartsQuestionsAlert", "BodyText");
+        },
         windshieldPart() {
             return this.pageData.partsOrQuestions.find(x => x.glassLocation === damageLocationsSelected.WINDSHIELD);
         },
@@ -111,28 +98,396 @@ export default {
             return this.$store.getters.pageData(fmgPageValues.CAPABILITY_QUESTIONS);
         }
     },
+    mounted() {
+        this.loadInitialCapabilityQuestionsData();
+    },
     methods: {
+        showThisPartQuestionChain(part, i) {
+            if (part.capabilityQuestions?.length < 1 || part.isSuppressedPart) { return false; } // return false if no capabilityQuestions or if suppressed
+            return this.currentQuestionChainIndex === i || part.answerData?.answerResult?.length > 0
+        },
         arePagePrerequisitesValid() {
             const capabilityQuestionsPageData = store.getters.pageData(fmgPageValues.CAPABILITY_QUESTIONS);
             return capabilityQuestionsPageData && Object.keys(capabilityQuestionsPageData).length > 0;
         },
         async forwardButtonAction() {
-            const selectedAnswerResult1 = this.selectedAnswer.answerResult;
-            const selectedAnswerResult2 = this.pageData.capabilityQuestions[0].answers.find(x => x.answerResult1 === selectedAnswerResult1).answerResult2;
+            const capabilityQuestionsAnswersArray = this.capabilityQuestionsData.map((item) => {
+                const selectedAnswerResult1 = item.answerData.answerResult;
+                const selectedAnswerResult2 = item.answerData.answerResult2;
 
-            this.dispatchStoreAction(storeActions.SAVE_CAPABILITY_QUESTION_ANSWERS, {
-                glassName: this.windshieldPart.glassName,
-                glassLocation: this.windshieldPart.glassLocation,
-                result1: selectedAnswerResult1,
-                result2: selectedAnswerResult2
+                return {
+                    glassLocation: item.glassLocation,
+                    glassName: item.glassName,
+                    result: item.answerData.answerResult,
+                    result1: selectedAnswerResult1,
+                    result2: selectedAnswerResult2,
+                    answeredQuestions: item.answerData.answeredQuestions,
+                    isSuppressedPart: item.isSuppressedPart,
+                };
             });
 
-            const partFromCapabilityQuestionAnswer = (await this.dispatchStoreAction(storeActions.GET_PART_FROM_CAPABILITY_QUESTION_ANSWER)).data;
+            // clear out answerData for future page loads; must occur prior to store save
+            this.capabilityQuestionsData.forEach((part) => {
+                part.answerData = {};
+            });
+
+            // save to vuex store as order.damage.capabilityQuestionAnswers (array)
+            await this.dispatchStoreAction(this.storeActions.SAVE_CAPABILITY_QUESTION_ANSWERS, capabilityQuestionsAnswersArray, false);
+
+            // get parts from the capabilityQuestionAnswers
             let partsOrQuestions = this.pageData.partsOrQuestions;
-            partsOrQuestions.find(partOrQuestion => partOrQuestion.glassLocation === damageLocationsSelected.WINDSHIELD).parts = partFromCapabilityQuestionAnswer;
+            for (let answer of capabilityQuestionsAnswersArray) {
+                const correspondingPart = partsOrQuestions.find(partOrQuestion => partOrQuestion.glassLocation === answer.glassLocation);
+                const partFromCapabilityQuestionAnswer = (await this.dispatchStoreAction(storeActions.GET_PART_FROM_CAPABILITY_QUESTION_ANSWER, answer.glassLocation, false)).data;
+
+                partsOrQuestions.find(partOrQuestion => partOrQuestion.glassLocation === answer.glassLocation).parts = partFromCapabilityQuestionAnswer;
+            }
 
             this.navigateForward(partsOrQuestions);
         },
+        handleAnswerUpdates(answer) {
+            // only runs when all questions in a question-chain have been answered
+            //      when selectedAnswers updates, user has completed this part's question chain and has a final answer
+            //      (does not get run for each invididual question's answer, only when 
+            //      all relevent questions for the current part have been answered)
+
+            /*
+            answer example format:
+            {
+                "answerResult": "DD11132",
+                "answeredQuestions": [
+                    {
+                        "questionText": "Is your Grand Cherokee the Laredo model?",
+                        "selectedAnswerText": "Yes",
+                        "questionNum": 1,
+                        "extra": {
+                            "Text": "Yes",
+                            "nextQuestionSequence": null,
+                            "answerResult": "DD11132",
+                            "questionSequence": 1,
+                            "questionType": "answer"
+                        }
+                    }
+                ],
+                "partIndex": 0
+            }
+            */
+
+            // collect a list of the answered questions' numbers, needed later below
+            const answeredQuestionIndexes = [];
+
+            // if user has answered a question differently than anything that was preloaded,
+            //     we need to clear out any preloaded answers
+            this.selectedAnswers = {};
+
+            // loop through every answered question on the currently answered glass part
+            answer.answeredQuestions?.forEach((aq) => {
+
+                // keep track of this question number
+                answeredQuestionIndexes.push(aq.questionNum);
+
+                const answeredQuestionText = aq.questionText.toUpperCase();
+                const answeredQuestionAnswer = aq.selectedAnswerText.toUpperCase();
+
+                // HANDLE DUPLICATE QUESTIONS
+
+                // loop through all glass parts data
+                this.capabilityQuestionsData.forEach((glassPart, gpIndex) => {
+
+                    // only look for duplicates forward... to parts that follow after the currently being answered part
+                    if (gpIndex > answer.partIndex) {
+
+                        let suppressUntil;
+                        // reset this glass part, in case user is changing their previous answers
+                        glassPart.answerData = null;
+                        glassPart.isSuppressedPart = null;
+
+                        // loop through this glass part's part questions, looking for a questionText match
+                        glassPart.capabilityQuestions.forEach((pq, pqIndex) => {
+
+                            // clear out any previously set answers
+                            pq.answerSelected = null;
+
+                            // clear or set suppressQuestion property for each question
+                            if (suppressUntil) {
+                                // if suppressUntil has been set, then suppress this question if before it
+                                if (pqIndex + 1 < suppressUntil) {
+                                    pq.suppressQuestion = true;
+                                } else {
+                                    pq.suppressQuestion = null;
+                                }
+                            } else {
+                                pq.suppressQuestion = null;
+                            }
+
+                            // if these match then we have a duplicate question
+                            if (pq.questionText.toUpperCase() === answeredQuestionText) {
+
+                                const thisAnsweredCapabilityQuestion = glassPart.capabilityQuestions[pqIndex];
+                                let matchedAnswer;
+                                let rejectedAnswers = []; // set as an array, in case we ever have questions with more than 2 answers...
+
+                                // which one of this capabilityQuestions' answers matches our answer?
+                                pq.answers.forEach((ans) => {
+                                    if (ans.answerText.toUpperCase() === answeredQuestionAnswer) {
+                                        matchedAnswer = ans;
+                                        ans.selected = true;
+                                    } else {
+                                        rejectedAnswers.push(ans);
+                                        ans.selected = null;
+                                    }
+                                });
+
+                                // Update the key to re-render this part's question-chain component
+                                this.capabilityQuestionsData[gpIndex].key = this.capabilityQuestionsData[gpIndex].glassLocation + this.capabilityQuestionsData[gpIndex].glassName + Date.now().toString();
+
+                                // handle suppressing downstream in this question chain
+
+                                if (matchedAnswer.nextQuestionSequence) {
+                                    // ensure that the question that the accepted answer has set to be next is NOT suppressed
+                                    glassPart.capabilityQuestions[matchedAnswer.nextQuestionSequence - 1].suppressQuestion = null;
+                                    // if the duplicate is the 1ST question, then set suppressUntil var to lowest nextQuestion number
+                                    if (pqIndex === 0) {
+                                        if (!suppressUntil) { suppressUntil = matchedAnswer.nextQuestionSequence }
+                                        if (matchedAnswer.nextQuestionSequence < suppressUntil) { suppressUntil = matchedAnswer.nextQuestionSequence }
+                                    }
+                                }
+
+                                // handle suppressing upstream in this question chain
+                                glassPart.capabilityQuestions.forEach((q) => {
+                                    q.answers.forEach((thisAns) => {
+                                        // restore any of the answers that formerly led to the duplicated question
+                                        if (thisAns.originalNextQuestionSequence === pq.questionSequence) {
+                                            // restore original nextQuestionSequence
+                                            thisAns.nextQuestionSequence = thisAns.originalNextQuestionSequence;
+                                            this.originalNextQuestionSequence = null;
+                                            // restore original answerResult
+                                            if (thisAns.originalAnswerResult) {
+                                                thisAns.answerResult = thisAns.originalAnswerResult;
+                                                thisAns.answerResult1 = thisAns.originalAnswerResult;
+                                                thisAns.originalAnswerResult = null;
+                                            }
+                                        }
+                                        // search for any answers that lead to the duplicated question
+                                        if (thisAns.nextQuestionSequence === pq.questionSequence) {
+                                            // update either the nextQuestionSequence or the answerResult
+                                            if (matchedAnswer.nextQuestionSequence) {
+                                                thisAns.originalNextQuestionSequence = thisAns.nextQuestionSequence;
+                                                thisAns.nextQuestionSequence = matchedAnswer.nextQuestionSequence;
+                                            } else {
+                                                thisAns.originalNextQuestionSequence = thisAns.nextQuestionSequence;
+                                                thisAns.nextQuestionSequence = null;
+                                                thisAns.originalAnswerResult = thisAns.originalAnswerResult || thisAns.answerResult;
+                                                thisAns.answerResult = matchedAnswer.answerResult;
+                                                thisAns.answerResult1 = matchedAnswer.answerResult;
+                                            }
+                                        }
+                                    });
+                                });
+
+                                // suppress current question
+                                thisAnsweredCapabilityQuestion.suppressQuestion = true;
+
+                                const thisGlassPart = "glassPart" + gpIndex;
+                                if (this.foundDuplicateQuestions[thisGlassPart]) {
+                                    if (!this.foundDuplicateQuestions[thisGlassPart].includes(thisAnsweredCapabilityQuestion.questionSequence)) {
+                                        this.foundDuplicateQuestions[thisGlassPart].push(thisAnsweredCapabilityQuestion.questionSequence);
+                                    }
+                                } else {
+                                    this.foundDuplicateQuestions[thisGlassPart] = [thisAnsweredCapabilityQuestion.questionSequence];
+                                }
+
+                                // are there any questions left that are not suppressed?
+                                const remainingQuestions = glassPart.capabilityQuestions.filter((q) => {
+                                    return !q.suppressQuestion;
+                                });
+
+                                if (remainingQuestions.length < 1) {
+                                    // this is the final answer for this glass part
+
+                                    // mark this part as completely answered by adding answerData
+                                    const answeredQuestionObj = {
+                                        questionText: pq.questionText,
+                                        selectedAnswerText: matchedAnswer.answerText,
+                                        questionNum: pq.questionSequence,
+                                        suppressQuestion: pq.suppressQuestion,
+                                    };
+                                    // set the answerData as 'already answered'
+                                    glassPart.answerData = {
+                                        answerResult: matchedAnswer.nextQuestionSequence ? matchedAnswer.nextQuestionSequence : matchedAnswer.answerResult,
+                                        answerResult1: matchedAnswer.nextQuestionSequence ? matchedAnswer.nextQuestionSequence : matchedAnswer.answerResult,
+                                        answeredQuestions: [answeredQuestionObj],
+                                    };
+
+                                    // suppress this glassPart because it has an answer
+                                    glassPart.isSuppressedPart = true;
+                                }
+
+                            }
+
+                        });
+
+                        // Update the key to re-render this part's question-chain component
+                        this.capabilityQuestionsData[gpIndex].key = this.capabilityQuestionsData[gpIndex].glassLocation + this.capabilityQuestionsData[gpIndex].glassName + Date.now().toString();
+                        
+                    }
+                });
+            });
+
+            // DETERMINE ANSWERED QUESTIONS LIST FOR THIS GLASS PART
+
+            // look through all (this part's) part questions for any duplicates that were suppressed; 
+            //      add them to the list of answered questions if found
+
+            // EX answeredQuestionIndexes: [1,5,11,13]
+
+            // EX this.foundDuplicateQuestions = {
+            //     "glassPart1": [1],
+            //     "glassPart2": [7, 10]
+            // };
+
+            const thisPartsDupes = this.foundDuplicateQuestions["glassPart" + answer.partIndex];
+            const completeAnsweredQuestions = answer.answeredQuestions ? [...answer.answeredQuestions] : [];
+            const glassPartAnswered = this.capabilityQuestionsData[answer.partIndex];
+
+            thisPartsDupes?.forEach((dupe) => {
+                // dupe is a single integer
+                const dupeQuestion = glassPartAnswered.capabilityQuestions[dupe - 1];
+                const dupeQuestionAnswer = dupeQuestion.answers.find((q) => q.selected === true);
+
+                glassPartAnswered.capabilityQuestions.forEach((q) => {
+                    let includeThisDupeInAnsweredQuestions = false;
+
+                    // did one of the answers of this question point to the duplicated question?
+                    q.answers.forEach((a) => {
+                        if ((dupe === a.originalNextQuestionSequence) &&
+                            (answeredQuestionIndexes.includes(q.questionSequence)) &&
+                            (a.answerText.toUpperCase() === dupeQuestionAnswer.answerText.toUpperCase())) {
+                            includeThisDupeInAnsweredQuestions = true;
+                        }
+                    });
+
+                    // is this q.questionSequence listed as the duplicated question's nextQuestionSequence?
+                    if ((q.questionSequence === dupeQuestionAnswer.nextQuestionSequence) && (answeredQuestionIndexes.includes(q.questionSequence))) {
+                        includeThisDupeInAnsweredQuestions = true;
+                    }
+
+                    if (includeThisDupeInAnsweredQuestions) {
+                        completeAnsweredQuestions.push({
+                            questionNum: dupeQuestion.questionSequence,
+                            questionText: dupeQuestion.questionText,
+                            selectedAnswerText: dupeQuestionAnswer.answerText,
+                            suppressQuestion: dupeQuestion.suppressQuestion,
+                        });
+                    }
+                });
+            });
+
+            // make sure there are no duplicated dupes in the list...
+            const foundInCompleteAnsweredQuestions = new Set();
+            let filteredCompleteAnsweredQuestions = completeAnsweredQuestions.filter(el => {
+                const duplicate = foundInCompleteAnsweredQuestions.has(el.questionText);
+                foundInCompleteAnsweredQuestions.add(el.questionText);
+                return !duplicate;
+            });
+            filteredCompleteAnsweredQuestions = filteredCompleteAnsweredQuestions.sort((a, b) => a.questionNum - b.questionNum);
+
+            const selectedAnswerResult1 = answer.answerResult;
+            const selectedAnswerResult2 = this.getCorrespondingAnswerResult2(selectedAnswerResult1);
+
+            // set final answer data for the current answered glass part
+            glassPartAnswered.answerData = {
+                answerResult: selectedAnswerResult1,
+                answerResult1: selectedAnswerResult1,
+                answerResult2: selectedAnswerResult2,
+                answeredQuestions: filteredCompleteAnsweredQuestions,
+            }
+
+            // this part has been fully answered, so advance to next part's question chain
+            for (let i = answer.partIndex + 1; i < this.capabilityQuestionsData.length; i++) {
+                // if this part has not yet been fully answered, then make it the current part
+                if (!this.capabilityQuestionsData[i].answerData?.answerResult) {
+                    this.currentQuestionChainIndex = i;
+                    break;
+                }
+            }
+        },
+        // TODO I'm sure there's a better/simplier way to do this that I'm missing but my brain's fried
+        // Find the part that has some answer that has an answerResult matching the selected answerResult, then get the corresponding answerResult2
+        getCorrespondingAnswerResult2(answerResult1) {
+            return this.capabilityQuestionsData
+                .find(part => part.capabilityQuestions.some(question => question.answers.some(answer => answer.answerResult == answerResult1)))     // found part
+                .capabilityQuestions.find(question => question.answers.some(answer => answer.answerResult == answerResult1))    // found question
+                .answers.find(answer => answer.answerResult == answerResult1)
+                .answerResult2;
+        },
+        loadInitialCapabilityQuestionsData() {
+            // are there alreadyAnsweredQuestions?
+            const alreadyAnsweredQuestions = store.getters.damage.capabilityQuestionAnswers;
+
+            this.capabilityQuestionsData = this.pageData.partsOrQuestions.filter(x => x.capabilityQuestions).map((part, i) => {
+                part.key = part.glassLocation + "-" + part.glassName;
+                this.selectedAnswers[part.key] = [];
+                if (!alreadyAnsweredQuestions) {
+                    part.answerData = null;
+                }
+
+                alreadyAnsweredQuestions?.forEach((savedPart) => {
+
+                    if (!savedPart.glassLocation || !savedPart.glassName || !savedPart.answeredQuestions || !savedPart.result) {
+                        return;
+                    }
+                    if (part.glassLocation === savedPart.glassLocation && part.glassName === savedPart.glassName) {
+                        let answerString = "";
+
+                        // matches; loop through answeredQuestions for matches
+                        savedPart.answeredQuestions.forEach((aq) => {
+                            if (!aq.questionNum || !aq.selectedAnswerText) {
+                                return;
+                            }
+                            // determine which answer was previously chosen
+                            const theAns = part.capabilityQuestions[aq.questionNum - 1].answers.find((a) => {
+                                return a.answerText.toUpperCase() === aq.selectedAnswerText.toUpperCase();
+                            });
+                            if (theAns.nextQuestionSequence) {
+                                answerString = `${aq.questionNum}|nextQuestion|${theAns.nextQuestionSequence}|${theAns.answerText}`
+                            } else {
+                                answerString = `${aq.questionNum}|answer|${theAns.answerResult}|${theAns.answerText}`
+                            }
+
+                            // mark this partQuestion as answered (question-chain will read this)
+                            part.capabilityQuestions[aq.questionNum - 1].answerSelected = answerString;
+                            // mark this partQuestion as duplicate if it is (question-chain will read this)
+                            if (aq.suppressQuestion) {
+                                part.capabilityQuestions[aq.questionNum - 1].suppressQuestion = true;
+                            }
+                        });
+
+                        // advance the currentQuestionChainIndex
+                        this.currentQuestionChainIndex = i;
+
+                        // add answerData to current part
+                        part.answerData = {
+                            answerResult: savedPart.result,
+                            answerResult1: savedPart.result,
+                            answerResult2: this.getCorrespondingAnswerResult2(savedPart.result),
+                            answeredQuestions: savedPart.answeredQuestions
+                        }
+                    }
+
+                });
+
+                // Set up watch for each set of part questions, which gets updated when all questions for a part have been answered
+                this.$watch("selectedAnswers." + part.key, (newValue) => {
+                    if (newValue) {
+                        this.handleAnswerUpdates(newValue);
+                    }
+                }, { deep: true })
+
+                return part;
+            });
+
+        },
     },
     components: {
         funnelHeader,
@@ -148,12 +503,13 @@ export default {
 </script>
 
 <style lang="scss">
-  .capability-questions {
-      .question-text {
+.capability-questions {
+    .question-text {
         margin-bottom: .5rem;
+
         span {
             text-align: left;
         }
     }
-  }
+}
 </style>
diff --git a/src/layouts/part-questions/part-questions.vue b/src/layouts/part-questions/part-questions.vue
index 881eaf90b..7de6eb5a2 100644
--- a/src/layouts/part-questions/part-questions.vue
+++ b/src/layouts/part-questions/part-questions.vue
@@ -20,7 +20,7 @@
                     :manualCopy="AlertFewMoreQuestionsCopy"
                     v-bind:isDismissible="false"
                 />
-                <div v-for="(part, i) in partsQuestionsData" :key="i">
+                <div v-for="(part, i) in partsQuestionsData" :key="part.key">
                     <questionChain
                         ref="questionChain"
                         :keyString="part.key"
diff --git a/src/main.js b/src/main.js
index 6a81170db..01aa5406d 100644
--- a/src/main.js
+++ b/src/main.js
@@ -6,6 +6,7 @@ import router from "./router";
 import store from "@/store";
 import baseMixin from "@/mixins/base-mixin.js";
 import analyticsMixin from "@/mixins/analytics-mixin.js";
+import experimentMixin from "@/mixins/experiment-mixin.js";
 import "../node_modules/bootstrap/dist/js/bootstrap.js";
 
 // Vue App Setup
@@ -17,5 +18,6 @@ vueApp.use(LoadScript);
 vueApp.use(Maska);
 vueApp.mixin(baseMixin);
 vueApp.mixin(analyticsMixin);
+vueApp.mixin(experimentMixin);
 
 vueApp.mount("#app");
diff --git a/src/mixins/vehicle-questions-mixin.js b/src/mixins/vehicle-questions-mixin.js
index 380805751..06776174f 100644
--- a/src/mixins/vehicle-questions-mixin.js
+++ b/src/mixins/vehicle-questions-mixin.js
@@ -68,42 +68,49 @@ export default {
         async navigateForward(partsOrQuestions, vm) {
             const self = vm ?? this;
             const currentPage = self.$route.query.fmgPage;
-            
+
             const hasPartQuestions = this.hasPartQuestions(partsOrQuestions)
             const hasGlassLocationWithMultipleParts = this.hasGlassLocationWithMultipleParts(partsOrQuestions);
             const hasChildPartQuestions = this.hasChildPartQuestions(partsOrQuestions);
             const hasCapabilityQuestions = this.hasCapabilityQuestions(partsOrQuestions);
 
             if (hasPartQuestions && this.currentPageComesBeforePage(currentPage, fmgPageValues.PART_QUESTIONS)) {
-                self.$router.navigateWithSaving(self.navigationScenarios.HAS_PART_QUESTIONS, self.$route, {}, {}, {partsOrQuestions: partsOrQuestions});
+                self.$router.navigateWithSaving(self.navigationScenarios.HAS_PART_QUESTIONS, self.$route, {}, {}, { partsOrQuestions: partsOrQuestions });
             }
             else if (hasGlassLocationWithMultipleParts && this.currentPageComesBeforePage(currentPage, fmgPageValues.VEHICLE_PARTS)) {
                 // if multiple parts on any glass
                 // go to vehicle-parts page and pass the partsData
-                self.$router.navigateWithSaving(self.navigationScenarios.HAS_MULTIPLE_PARTS_TO_CHOOSE,self.$route,{},{},{partsOrQuestions: partsOrQuestions});
+                self.$router.navigateWithSaving(self.navigationScenarios.HAS_MULTIPLE_PARTS_TO_CHOOSE, self.$route, {}, {}, { partsOrQuestions: partsOrQuestions });
             } else if (hasChildPartQuestions && this.currentPageComesBeforePage(currentPage, fmgPageValues.MOLDING_QUESTIONS)) {
                 // if any childpart questions
                 // go to molding-questions page and pass the partsData
-                self.$router.navigateWithSaving(self.navigationScenarios.HAS_MOLDING_QUESTIONS,self.$route,{},{},{partsOrQuestions: partsOrQuestions});
+                self.$router.navigateWithSaving(self.navigationScenarios.HAS_MOLDING_QUESTIONS, self.$route, {}, {}, { partsOrQuestions: partsOrQuestions });
             } else if (hasCapabilityQuestions && this.currentPageComesBeforePage(currentPage, fmgPageValues.CAPABILITY_QUESTIONS)) {
                 // if has capability questions
                 // go to capability-questions page and pass the partsData
-                const windshieldPart = partsOrQuestions.filter(x => x.glassLocation === damageLocationsSelected.WINDSHIELD)[0].parts[0];
-                let capabilityQuestions = (await baseMixin.methods.dispatchStoreAction(storeActions.GET_CAPABILITY_QUESTIONS, {
-                    carId: store.getters.vehicle.carId,
-                    partNumber: windshieldPart.partNumber
-                })).data;
 
-                capabilityQuestions.forEach(question => {
-                    question.answers = question.answers.map(answer => {
-                        return {
-                            ...answer,
-                            answerResult: answer.answerResult1
-                        }
-                    })
-                });
-                
-                self.$router.navigateWithSaving(self.navigationScenarios.HAS_CAPABILITY_QUESTIONS, self.$route, {}, {}, { partsOrQuestions, capabilityQuestions });
+                // mimic part-questions page data for consistency
+                for (let partOrQuestion of partsOrQuestions) {
+                    if (this.hasCapabilityQuestions([partOrQuestion])) {
+                        let capabilityQuestionsForGlassLocation = (await baseMixin.methods.dispatchStoreAction(storeActions.GET_CAPABILITY_QUESTIONS, {
+                            carId: store.getters.vehicle.carId,
+                            partNumber: partOrQuestion.parts[0].partNumber
+                        })).data;
+
+                        capabilityQuestionsForGlassLocation.forEach(question => {
+                            question.answers = question.answers.map(answer => {
+                                return {
+                                    ...answer,
+                                    answerResult: answer.answerResult1
+                                }
+                            })
+                        })
+
+                        partOrQuestion.capabilityQuestions = capabilityQuestionsForGlassLocation;
+                    }
+                }
+
+                self.$router.navigateWithSaving(self.navigationScenarios.HAS_CAPABILITY_QUESTIONS, self.$route, {}, {}, { partsOrQuestions });
             } else {
                 // if single parts only
                 const collectedGlassParts = this.reducedGlassPartsArray(partsOrQuestions);
@@ -112,9 +119,6 @@ export default {
 
                 self.$refs.loadingModal.showModal();
                 navigateToHeritageFunnel();
-               
-                // For quote pages MVP release
-                // self.$router.navigate(self.navigationScenarios.HAS_NO_MORE_QUESTIONS, self.$route);
             }
         },
         backButtonAction() {
diff --git a/src/mixins/vehicle-questions-mixin.spec.js b/src/mixins/vehicle-questions-mixin.spec.js
index 954349c53..05d019da5 100644
--- a/src/mixins/vehicle-questions-mixin.spec.js
+++ b/src/mixins/vehicle-questions-mixin.spec.js
@@ -944,6 +944,7 @@ describe("vehicle-questions-mixin", () => {
                                 "childPartQuestions": null
                             }
                         ],
+                        "capabilityQuestions": [],
                         "partQuestions": null
                     }
                 ];
@@ -957,7 +958,7 @@ describe("vehicle-questions-mixin", () => {
 
                 // Assert
                 expect(wrapper.vm.$router.navigateWithSaving).toHaveBeenCalledTimes(1);
-                expect(wrapper.vm.$router.navigateWithSaving).toHaveBeenCalledWith(navigationScenarios.HAS_CAPABILITY_QUESTIONS, wrapper.vm.$route, {}, {}, { partsOrQuestions, capabilityQuestions: [] });
+                expect(wrapper.vm.$router.navigateWithSaving).toHaveBeenCalledWith(navigationScenarios.HAS_CAPABILITY_QUESTIONS, wrapper.vm.$route, {}, {}, { partsOrQuestions });
             });
         });
 
diff --git a/src/store/index.js b/src/store/index.js
index 359d9cb3b..9c81b88e0 100644
--- a/src/store/index.js
+++ b/src/store/index.js
@@ -749,18 +749,19 @@ export const actions = {
     })
   },
 
-  getPartFromCapabilityQuestionAnswer(context, selectedAnswerResult1) {
+  getPartFromCapabilityQuestionAnswer(context, glassLocation) {
     const pageData = context.getters.pageData(fmgPageValues.CAPABILITY_QUESTIONS);
 
-    const part = pageData.partsOrQuestions.find(x => x.glassLocation === damageLocationsSelected.WINDSHIELD).parts[0];
+    const part = pageData.partsOrQuestions.find(x => x.glassLocation === glassLocation).parts[0];
     const capabilityQuestionAnswers = context.getters.damage.capabilityQuestionAnswers;
+    const capabilityQuestionAnswersForPart = capabilityQuestionAnswers.find(x => x.glassLocation === glassLocation);
       
     return globalMethods.callHttpClient({
-      method: endpoints.ApplyCapabilityAnswerToPart.method,
-      endpoint: endpoints.ApplyCapabilityAnswerToPart.url,
+      method: endpoints.GetPartFromCapabilityAnswer.method,
+      endpoint: endpoints.GetPartFromCapabilityAnswer.url,
       payload: {
         part,
-        capabilityAnswerResults: capabilityQuestionAnswers
+        capabilityAnswerResults: capabilityQuestionAnswersForPart
       }
     })
   },
diff --git a/src/ux-components/list-button/list-button.vue b/src/ux-components/list-button/list-button.vue
index 178839e27..e51d5cc77 100644
--- a/src/ux-components/list-button/list-button.vue
+++ b/src/ux-components/list-button/list-button.vue
@@ -134,6 +134,7 @@ export default {
         value: this.value.toString(),
         buttonId: this.buttonID && this.buttonID.toString(),
       };
+
       this.handleChange(this.value);
       this.$emit("isCheckedChanged", emitEvent);
       this.$emit("update:modelValue", emitEvent);