diff --git a/docs/DataStructure.md b/docs/DataStructure.md
index d0e9acfa34..b64fcbcb41 100644
--- a/docs/DataStructure.md
+++ b/docs/DataStructure.md
@@ -1,5 +1,5 @@
 <!--
-  - SPDX-FileCopyrightText: 2021 Nextcloud GmbH and Nextcloud contributors
+  - SPDX-FileCopyrightText: 2021-2026 Nextcloud GmbH and Nextcloud contributors
   - SPDX-License-Identifier: AGPL-3.0-only
 -->
 
@@ -240,6 +240,7 @@ Currently supported Question-Types are:
 | `linearscale`     | A linear or Likert scale question where you choose an option that best fits your opinion                                                                                          |
 | `color`           | A color answer, hex string representation (e. g. `#123456`)                                                                                                                       |
 | `ranking`         | Using pre-defined options, the user ranks them from most to least preferred. Needs at least one option available. Answers are stored in ranked order (one answer row per option). |
+| `conditional`     | A conditional branching question with a trigger question and multiple branches containing subquestions                                                                            |
 
 ## Extra Settings
 
@@ -282,3 +283,126 @@ Supported option types and their intended usage.
 | `column` | Represents a column header when rendering options in a grid-style question.                |
 
 `row` and `column` option types are primarily used together with `grid` question types to build a two-dimensional selection matrix. `choice` is the default for normal option lists.
+| `triggerType` | `conditional` | string | [See trigger types](#conditional-trigger-types) | The type of trigger question (dropdown, multiple_unique, etc.) |
+| `branches` | `conditional` | Array | Array of [Branch objects](#branch-object) | The branches with conditions and subquestions |
+
+## Conditional Questions
+
+Conditional questions enable branching logic in forms. A trigger question determines which branch of subquestions appears based on the respondent's answer.
+
+### Question Properties for Subquestions
+
+Subquestions (questions belonging to a conditional question's branch) have additional properties:
+
+| Property         | Type    | Description                                                            |
+| ---------------- | ------- | ---------------------------------------------------------------------- |
+| parentQuestionId | Integer | The ID of the parent conditional question (null for regular questions) |
+| branchId         | String  | The ID of the branch this subquestion belongs to                       |
+
+### Conditional Trigger Types
+
+Supported trigger types for conditional questions:
+
+| Trigger Type      | Condition Types                                                             | Description                                       |
+| ----------------- | --------------------------------------------------------------------------- | ------------------------------------------------- |
+| `multiple_unique` | `option_selected`                                                           | Radio buttons - the selected option               |
+| `dropdown`        | `option_selected`                                                           | Dropdown - the selected option                    |
+
+A branch is shown when any of its conditions matches. Several branches can be shown at once.
+
+### Branch Object
+
+A branch defines conditions and subquestions that appear when those conditions are met.
+
+| Property     | Type                                     | Description                                    |
+| ------------ | ---------------------------------------- | ---------------------------------------------- |
+| id           | String                                   | Unique identifier for the branch               |
+| conditions   | Array of [Conditions](#condition-object) | Conditions that must be met to show the branch |
+| subQuestions | Array of [Questions](#question)          | Questions shown when conditions are met        |
+
+```json
+{
+	"id": "branch-1705587600000",
+	"conditions": [{ "type": "option_selected", "optionId": 42 }],
+	"subQuestions": [
+		{
+			"id": 101,
+			"formId": 3,
+			"order": 1,
+			"type": "short",
+			"text": "Please provide details",
+			"parentQuestionId": 100,
+			"branchId": "branch-1705587600000"
+		}
+	]
+}
+```
+
+### Condition Object
+
+Conditions determine when a branch is activated. The structure depends on the trigger type.
+
+#### option_selected (for dropdown, multiple_unique)
+
+```json
+{ "type": "option_selected", "optionId": 42 }
+```
+
+### Conditional Question Example
+
+A complete conditional question structure:
+
+```json
+{
+	"id": 100,
+	"formId": 3,
+	"order": 1,
+	"type": "conditional",
+	"isRequired": true,
+	"text": "Do you have any dietary restrictions?",
+	"options": [
+		{ "id": 42, "questionId": 100, "order": 1, "text": "Yes" },
+		{ "id": 43, "questionId": 100, "order": 2, "text": "No" }
+	],
+	"extraSettings": {
+		"triggerType": "dropdown",
+		"branches": [
+			{
+				"id": "branch-yes",
+				"conditions": [{ "type": "option_selected", "optionId": 42 }],
+				"subQuestions": [
+					{
+						"id": 101,
+						"formId": 3,
+						"order": 1,
+						"type": "long",
+						"text": "Please describe your dietary restrictions",
+						"parentQuestionId": 100,
+						"branchId": "branch-yes"
+					}
+				]
+			}
+		]
+	}
+}
+```
+
+### Conditional Answer Structure
+
+When submitting or storing conditional question answers, the structure differs from regular questions:
+
+```json
+{
+	"100": {
+		"trigger": ["42"],
+		"subQuestions": {
+			"101": ["Vegetarian, no nuts"]
+		}
+	}
+}
+```
+
+| Property     | Type                        | Description                                         |
+| ------------ | --------------------------- | --------------------------------------------------- |
+| trigger      | Array of strings            | Answer values for the trigger question              |
+| subQuestions | Object (questionId → Array) | Map of subquestion IDs to their answer value arrays |
diff --git a/lib/Analytics/AnalyticsDatasource.php b/lib/Analytics/AnalyticsDatasource.php
index 62f520b4b4..880e9bea35 100644
--- a/lib/Analytics/AnalyticsDatasource.php
+++ b/lib/Analytics/AnalyticsDatasource.php
@@ -101,8 +101,8 @@ public function readData($option): array {
 
 		$formId = $option['formId'];
 
-		$questions = $this->formsService->getQuestions($formId);
-		foreach ($questions as $question) {
+		// Answers of subquestions are counted with the text of their subquestion
+		foreach (FormsService::flattenQuestions($this->formsService->getQuestions($formId)) as $question) {
 			$questionMap[$question['id']] = $question['text'];
 		}
 
diff --git a/lib/Constants.php b/lib/Constants.php
index 3e465cd0cd..8058242ce6 100644
--- a/lib/Constants.php
+++ b/lib/Constants.php
@@ -1,7 +1,7 @@
 <?php
 
 /**
- * SPDX-FileCopyrightText: 2021 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2021-2026 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
@@ -101,6 +101,7 @@ class Constants {
 
 	// Available AnswerTypes
 	public const ANSWER_TYPE_COLOR = 'color';
+	public const ANSWER_TYPE_CONDITIONAL = 'conditional';
 	public const ANSWER_TYPE_DATE = 'date';
 	public const ANSWER_TYPE_DATETIME = 'datetime';
 	public const ANSWER_TYPE_DROPDOWN = 'dropdown';
@@ -121,6 +122,7 @@ class Constants {
 	// All AnswerTypes
 	public const ANSWER_TYPES = [
 		self::ANSWER_TYPE_COLOR,
+		self::ANSWER_TYPE_CONDITIONAL,
 		self::ANSWER_TYPE_DATE,
 		self::ANSWER_TYPE_DATETIME,
 		self::ANSWER_TYPE_DROPDOWN,
@@ -239,6 +241,35 @@ class Constants {
 		self::ANSWER_GRID_TYPE_RADIO,
 	];
 
+	/**
+	 * Extra settings for conditional questions
+	 * - triggerType: The question type used for the trigger (e.g., 'multiple_unique', 'dropdown', 'short')
+	 * - branches: Array of branch definitions, each containing:
+	 *   - id: Unique branch identifier
+	 *   - conditions: Array of condition objects defining when this branch is active
+	 *     For predefined types: [{ optionId: number }]
+	 *     For text types: [{ type: 'string_equals'|'string_contains'|'regex', value: string }]
+	 *     For numeric/scale: [{ type: 'value_equals'|'value_range', value: number, min?: number, max?: number }]
+	 */
+	public const EXTRA_SETTINGS_CONDITIONAL = [
+		'triggerType' => ['string'],
+		'branches' => ['array'],
+	];
+
+	/**
+	 * Condition types for conditional questions
+	 */
+	public const CONDITION_TYPE_OPTION_SELECTED = 'option_selected';
+
+	/**
+	 * Trigger types allowed for conditional questions
+	 * Maps each trigger type to its supported condition types
+	 */
+	public const CONDITIONAL_TRIGGER_TYPES = [
+		self::ANSWER_TYPE_MULTIPLEUNIQUE => [self::CONDITION_TYPE_OPTION_SELECTED],
+		self::ANSWER_TYPE_DROPDOWN => [self::CONDITION_TYPE_OPTION_SELECTED],
+	];
+
 	/**
 	 * !! Keep in sync with src/mixins/ShareTypes.js !!
 	 */
diff --git a/lib/Controller/ApiController.php b/lib/Controller/ApiController.php
index 14bf7ea966..fcd103b34d 100644
--- a/lib/Controller/ApiController.php
+++ b/lib/Controller/ApiController.php
@@ -1,7 +1,7 @@
 <?php
 
 /**
- * SPDX-FileCopyrightText: 2017 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2017-2026 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
@@ -235,15 +235,10 @@ public function newForm(?int $fromId = null): DataResponse {
 					$form->setConfirmationEmailQuestionId($newQuestion->getId());
 				}
 
-				// Get Options, set new QuestionId, reinsert
-				$options = $this->optionMapper->findByQuestion($oldQuestion->getId());
-				foreach ($options as $oldOption) {
-					$optionData = $oldOption->read();
+				$copiedOptions = $this->copyOptions($oldQuestion->getId(), $newQuestion->getId());
 
-					unset($optionData['id']);
-					$optionData['questionId'] = $newQuestion->getId();
-					$newOption = Option::fromParams($optionData);
-					$this->optionMapper->insert($newOption);
+				if ($newQuestion->getType() === Constants::ANSWER_TYPE_CONDITIONAL) {
+					$this->copyConditionalBranches($oldQuestion, $newQuestion, $copiedOptions);
 				}
 			}
 
@@ -530,6 +525,8 @@ public function getQuestion(int $formId, int $questionId): DataResponse {
 	 * @param FormsQuestionGridCellType $subtype the new question subtype
 	 * @param string $text the new question title
 	 * @param ?int $fromId (optional) id of the question that should be cloned
+	 * @param ?int $parentQuestionId (optional) id of the parent conditional question (for subquestions)
+	 * @param ?string $branchId (optional) branch id within the parent conditional question
 	 * @param ?int $position (optional) the position of the new question
 	 * @return DataResponse<Http::STATUS_CREATED, FormsQuestion, array{}>
 	 * @throws OCSBadRequestException Invalid type
@@ -545,7 +542,7 @@ public function getQuestion(int $formId, int $questionId): DataResponse {
 	#[NoAdminRequired()]
 	#[BruteForceProtection(action: 'form')]
 	#[ApiRoute(verb: 'POST', url: '/api/v3/forms/{formId}/questions')]
-	public function newQuestion(int $formId, ?string $type = null, ?string $subtype = null, string $text = '', ?int $fromId = null, ?int $position = null): DataResponse {
+	public function newQuestion(int $formId, ?string $type = null, ?string $subtype = null, string $text = '', ?int $fromId = null, ?int $parentQuestionId = null, ?string $branchId = null, ?int $position = null): DataResponse {
 		$form = $this->formsService->getFormIfAllowed($formId, Constants::PERMISSION_EDIT);
 		$this->formsService->obtainFormLock($form);
 
@@ -555,10 +552,12 @@ public function newQuestion(int $formId, ?string $type = null, ?string $subtype
 		}
 
 		if ($fromId === null) {
-			$this->logger->debug('Adding new question: formId: {formId}, type: {type}, text: {text}', [
+			$this->logger->debug('Adding new question: formId: {formId}, type: {type}, text: {text}, parentQuestionId: {parentQuestionId}, branchId: {branchId}', [
 				'formId' => $formId,
 				'type' => $type,
 				'text' => $text,
+				'parentQuestionId' => $parentQuestionId,
+				'branchId' => $branchId,
 			]);
 
 			if (array_search($type, Constants::ANSWER_TYPES) === false) {
@@ -572,8 +571,54 @@ public function newQuestion(int $formId, ?string $type = null, ?string $subtype
 				throw new OCSBadRequestException('Datetime question type no longer supported');
 			}
 
+			// Block creation of nested conditional questions (conditional within conditional)
+			if ($type === Constants::ANSWER_TYPE_CONDITIONAL && $parentQuestionId !== null) {
+				$this->logger->debug('Nested conditional questions are not supported');
+				throw new OCSBadRequestException('Nested conditional questions are not supported');
+			}
+
+			// Validate parent question if creating a subquestion
+			if ($parentQuestionId !== null) {
+				try {
+					$parentQuestion = $this->questionMapper->findById($parentQuestionId);
+				} catch (IMapperException $e) {
+					$this->logger->debug('Could not find parent question');
+					throw new OCSNotFoundException('Could not find parent question');
+				}
+
+				// Parent must belong to the same form, checked first to not tell anything about questions of other forms
+				if ($parentQuestion->getFormId() !== $formId) {
+					$this->logger->debug('Parent question does not belong to this form');
+					throw new OCSBadRequestException('Parent question does not belong to this form');
+				}
+
+				// Parent must be a conditional question
+				if ($parentQuestion->getType() !== Constants::ANSWER_TYPE_CONDITIONAL) {
+					$this->logger->debug('Parent question must be a conditional question');
+					throw new OCSBadRequestException('Parent question must be a conditional question');
+				}
+
+				// branchId is required when parentQuestionId is set
+				if (empty($branchId)) {
+					$this->logger->debug('branchId is required when creating a subquestion');
+					throw new OCSBadRequestException('branchId is required when creating a subquestion');
+				}
+
+				// The branch must exist on the parent question
+				$branchIds = array_column($parentQuestion->getExtraSettings()['branches'] ?? [], 'id');
+				if (!in_array($branchId, $branchIds, true)) {
+					$this->logger->debug('Branch does not exist on the parent question');
+					throw new OCSBadRequestException('Branch does not exist on the parent question');
+				}
+			}
+
 			// Retrieve all active questions sorted by Order.
-			$questions = $this->questionMapper->findByForm($formId);
+			// For subquestions, get order within the branch
+			if ($parentQuestionId !== null) {
+				$questions = $this->questionMapper->findByBranch($parentQuestionId, $branchId);
+			} else {
+				$questions = $this->questionMapper->findByForm($formId);
+			}
 
 			if ($position !== null) {
 				$position = $this->shiftQuestionsForInsert($questions, $position);
@@ -598,6 +643,12 @@ public function newQuestion(int $formId, ?string $type = null, ?string $subtype
 			$question->setIsRequired(false);
 			$question->setExtraSettings($subtype ? ['questionType' => $subtype] : []);
 
+			// Set parent question and branch for subquestions
+			if ($parentQuestionId !== null) {
+				$question->setParentQuestionId($parentQuestionId);
+				$question->setBranchId($branchId);
+			}
+
 			$question = $this->questionMapper->insert($question);
 
 			$response = $this->formsService->getQuestion($question->getId());
@@ -617,13 +668,16 @@ public function newQuestion(int $formId, ?string $type = null, ?string $subtype
 				if ($sourceQuestion->getFormId() !== $formId) {
 					throw new OCSBadRequestException('Question doesn\'t belong to given form');
 				}
-				$sourceOptions = $this->optionMapper->findByQuestion($fromId);
 			} catch (IMapperException) {
 				$this->logger->debug('Could not find question');
 				throw new OCSNotFoundException('Could not find question');
 			}
 
-			$allQuestions = $this->questionMapper->findByForm($formId);
+			// Subquestions are ordered within their branch
+			$sourceParentId = $sourceQuestion->getParentQuestionId();
+			$allQuestions = $sourceParentId !== null
+				? $this->questionMapper->findByBranch($sourceParentId, (string)$sourceQuestion->getBranchId())
+				: $this->questionMapper->findByForm($formId);
 
 			$questionData = $sourceQuestion->read();
 			unset($questionData['id']);
@@ -638,19 +692,18 @@ public function newQuestion(int $formId, ?string $type = null, ?string $subtype
 			$newQuestion = Question::fromParams($questionData);
 			$this->questionMapper->insert($newQuestion);
 
-			$response = $newQuestion->read();
-			$response['options'] = [];
-			$response['accept'] = [];
-
-			foreach ($sourceOptions as $sourceOption) {
-				$optionData = $sourceOption->read();
-
-				unset($optionData['id']);
-				$optionData['questionId'] = $newQuestion->getId();
-				$newOption = Option::fromParams($optionData);
-				$insertedOption = $this->optionMapper->insert($newOption);
+			$copiedOptions = $this->copyOptions($fromId, $newQuestion->getId());
 
-				$response['options'][] = $insertedOption->read();
+			if ($newQuestion->getType() === Constants::ANSWER_TYPE_CONDITIONAL) {
+				$this->copyConditionalBranches($sourceQuestion, $newQuestion, $copiedOptions);
+				$response = $this->formsService->getQuestion($newQuestion->getId());
+				if ($response === null) {
+					throw new OCSException('Failed to copy question');
+				}
+			} else {
+				$response = $newQuestion->read();
+				$response['options'] = array_values(array_map(static fn (Option $option) => $option->read(), $copiedOptions));
+				$response['accept'] = [];
 			}
 		}
 
@@ -672,8 +725,9 @@ public function newQuestion(int $formId, ?string $type = null, ?string $subtype
 	 * @param array<string, mixed> $keyValuePairs Array of key=>value pairs to update.
 	 * @return DataResponse<Http::STATUS_OK, int, array{}>
 	 * @throws OCSBadRequestException Question doesn\'t belong to given Form
-	 * @throws OCSBadRequestException Invalid extraSettings, will not update.
+	 * @throws OCSBadRequestException Invalid extraSettings, or a type change to or from a conditional question, will not update
 	 * @throws OCSForbiddenException Empty keyValuePairs, will not update
+	 * @throws OCSForbiddenException Not allowed to update `parentQuestionId`, `branchId`, `options` or `accept`
 	 * @throws OCSForbiddenException Not allowed to update `id` or `formId`
 	 * @throws OCSForbiddenException Please use reorderQuestions() to change order
 	 * @throws OCSForbiddenException This form is archived and can not be modified
@@ -727,6 +781,23 @@ public function updateQuestion(int $formId, int $questionId, array $keyValuePair
 			throw new OCSForbiddenException('Not allowed to update \'id\' or \'formId\'');
 		}
 
+		// The place of a subquestion is fixed on creation, options and accept have their own handling
+		foreach (['parentQuestionId', 'branchId', 'options', 'accept'] as $key) {
+			if (array_key_exists($key, $keyValuePairs)) {
+				$this->logger->debug('Not allowed to update \'{key}\'', ['key' => $key]);
+				throw new OCSForbiddenException('Not allowed to update \'' . $key . '\'');
+			}
+		}
+
+		// Conditional questions can not be changed into another type and vice versa,
+		// the subquestions would be lost or end up nested
+		if (array_key_exists('type', $keyValuePairs)
+			&& $keyValuePairs['type'] !== $question->getType()
+			&& ($keyValuePairs['type'] === Constants::ANSWER_TYPE_CONDITIONAL || $question->getType() === Constants::ANSWER_TYPE_CONDITIONAL)) {
+			$this->logger->debug('Not allowed to change the type of or into a conditional question');
+			throw new OCSBadRequestException('Not allowed to change the type of or into a conditional question');
+		}
+
 		// Don't allow to reorder here
 		if (array_key_exists('order', $keyValuePairs)) {
 			$this->logger->debug('Key \'order\' is not allowed on updateQuestion. Please use reorderQuestions() to change order.');
@@ -742,6 +813,10 @@ public function updateQuestion(int $formId, int $questionId, array $keyValuePair
 			$form->setConfirmationEmailQuestionId(null);
 		}
 
+		if ($question->getType() === Constants::ANSWER_TYPE_CONDITIONAL && isset($keyValuePairs['extraSettings']['branches'])) {
+			$keyValuePairs['extraSettings'] = $this->updateConditionalBranches($form, $question, $keyValuePairs['extraSettings']);
+		}
+
 		// Create QuestionEntity with given Params & Id.
 		$question = Question::fromParams($keyValuePairs);
 		$question->setId($questionId);
@@ -798,6 +873,13 @@ public function deleteQuestion(int $formId, int $questionId): DataResponse {
 		// Store Order of deleted Question
 		$deletedOrder = $question->getOrder();
 
+		// If this is a conditional question, also soft-delete its subquestions
+		if ($question->getType() === Constants::ANSWER_TYPE_CONDITIONAL) {
+			foreach ($this->questionMapper->findByParentQuestion($questionId) as $subQuestion) {
+				$this->deleteSubQuestion($form, $subQuestion);
+			}
+		}
+
 		// Mark question as deleted
 		$question->setOrder(0);
 		$this->questionMapper->update($question);
@@ -810,8 +892,11 @@ public function deleteQuestion(int $formId, int $questionId): DataResponse {
 			]);
 		}
 
-		// Update all question-order > deleted order.
-		$formQuestions = $this->questionMapper->findByForm($formId);
+		// Update all question-order > deleted order, subquestions are ordered within their branch
+		$parentQuestionId = $question->getParentQuestionId();
+		$formQuestions = $parentQuestionId !== null
+			? $this->questionMapper->findByBranch($parentQuestionId, (string)$question->getBranchId())
+			: $this->questionMapper->findByForm($formId);
 		foreach ($formQuestions as $question) {
 			$questionOrder = $question->getOrder();
 			if ($questionOrder > $deletedOrder) {
@@ -838,6 +923,7 @@ public function deleteQuestion(int $formId, int $questionId): DataResponse {
 	 * @throws OCSBadRequestException The given array contains duplicates
 	 * @throws OCSBadRequestException The length of the given array does not match the number of stored questions
 	 * @throws OCSBadRequestException Question doesn't belong to given Form
+	 * @throws OCSBadRequestException Subquestions can only be reordered within their branch
 	 * @throws OCSBadRequestException One question has already been marked as deleted
 	 * @throws OCSForbiddenException This form is archived and can not be modified
 	 * @throws OCSForbiddenException User has no permissions to get this form
@@ -899,6 +985,149 @@ public function reorderQuestions(int $formId, array $newOrder): DataResponse {
 				throw new OCSBadRequestException('Question doesn\'t belong to given Form');
 			}
 
+			// Subquestions are ordered within their branch, not among the questions of the form
+			if ($questions[$arrayKey]->getParentQuestionId() !== null) {
+				$this->logger->debug('This question is a subquestion: {questionId}', [
+					'questionId' => $questionId
+				]);
+				throw new OCSBadRequestException('Subquestions can only be reordered within their branch');
+			}
+
+			// Abort if a question is already marked as deleted (order==0)
+			$oldOrder = $questions[$arrayKey]->getOrder();
+			if ($oldOrder === 0) {
+				$this->logger->debug('This question has already been marked as deleted: Id: {questionId}', [
+					'questionId' => $questions[$arrayKey]->getId()
+				]);
+				throw new OCSBadRequestException('One question has already been marked as deleted');
+			}
+
+			// Only set order, if it changed.
+			if ($oldOrder !== $arrayKey + 1) {
+				// Set Order. ArrayKey counts from zero, order counts from 1.
+				$questions[$arrayKey]->setOrder($arrayKey + 1);
+			}
+		}
+
+		// Write to Database
+		foreach ($questions as $question) {
+			$this->questionMapper->update($question);
+
+			$response[(string)$question->getId()] = [
+				'order' => $question->getOrder()
+			];
+		}
+
+		$this->formMapper->update($form);
+
+		return new DataResponse($response);
+	}
+
+	/**
+	 * Updates the Order of all Questions in a Branch of a conditional
+	 *
+	 * @param int $formId Id of the form to reorder
+	 * @param string $branchId Id of the branch.
+	 * @param int $parentQuestionId Id of the parent trigger question.
+	 * @param list<int> $newOrder Array of Question-Ids in new order.
+	 * @return DataResponse<Http::STATUS_OK, array<string, FormsOrder>, array{}>
+	 * @throws OCSBadRequestException The given array contains duplicates
+	 * @throws OCSBadRequestException The length of the given array does not match the number of stored questions
+	 * @throws OCSBadRequestException Question doesn't belong to given Form
+	 * @throws OCSBadRequestException One question has already been marked as deleted
+	 * @throws OCSForbiddenException This form is archived and can not be modified
+	 * @throws OCSForbiddenException User has no permissions to get this form
+	 * @throws OCSNotFoundException Could not find form
+	 * @throws OCSNotFoundException Could not find question
+	 *
+	 * 200: the question ids of the given form in the new order
+	 */
+	#[CORS()]
+	#[NoAdminRequired()]
+	#[BruteForceProtection(action: 'form')]
+	#[ApiRoute(verb: 'PATCH', url: '/api/v3/forms/{formId}/subquestions')]
+	public function reorderSubQuestions(int $formId, string $branchId, int $parentQuestionId, array $newOrder): DataResponse {
+		$this->logger->debug('Reordering Sub-Questions on Form {formId}, Parent-Question {parentQuestionId}, Branch {branchId} as Question-Ids {newOrder}', [
+			'formId' => $formId,
+			'parentQuestionId' => $parentQuestionId,
+			'branchId' => $branchId,
+			'newOrder' => $newOrder
+		]);
+
+		$form = $this->formsService->getFormIfAllowed($formId, Constants::PERMISSION_EDIT);
+		$this->formsService->obtainFormLock($form);
+
+		if ($this->formsService->isFormArchived($form)) {
+			$this->logger->debug('This form is archived and can not be modified');
+			throw new OCSForbiddenException('This form is archived and can not be modified');
+		}
+
+		// Check if array contains duplicates
+		if (array_unique($newOrder) !== $newOrder) {
+			$this->logger->debug('The given array contains duplicates');
+			throw new OCSBadRequestException('The given array contains duplicates');
+		}
+
+		// The parent question must belong to the form, so nothing is told about questions of other forms
+		try {
+			$parentQuestion = $this->questionMapper->findById($parentQuestionId);
+		} catch (IMapperException $e) {
+			$this->logger->debug('Could not find question {questionId}', [
+				'questionId' => $parentQuestionId
+			]);
+			throw new OCSNotFoundException('Could not find question');
+		}
+		if ($parentQuestion->getFormId() !== $formId) {
+			$this->logger->debug('This Question is not part of the given form: {questionId}', [
+				'questionId' => $parentQuestionId
+			]);
+			throw new OCSBadRequestException('Question doesn\'t belong to given Form');
+		}
+
+		// Check if all questions are given in Array.
+		$questions = $this->questionMapper->findByBranch($parentQuestionId, $branchId);
+		if (sizeof($questions) !== sizeof($newOrder)) {
+			$this->logger->debug('The length of the given array does not match the number of stored questions');
+			throw new OCSBadRequestException('The length of the given array does not match the number of stored questions');
+		}
+
+		$questions = []; // Clear Array of Entities
+		$response = []; // Array of ['questionId' => ['order' => newOrder]]
+
+		// Store array of Question-Entities and check the Questions FormId & old Order.
+		foreach ($newOrder as $arrayKey => $questionId) {
+			try {
+				$questions[$arrayKey] = $this->questionMapper->findById($questionId);
+			} catch (IMapperException $e) {
+				$this->logger->debug('Could not find question {questionId}', [
+					'questionId' => $questionId
+				]);
+				throw new OCSNotFoundException('Could not find question');
+			}
+
+			// Abort if a question is not part of the Form.
+			if ($questions[$arrayKey]->getFormId() !== $formId) {
+				$this->logger->debug('This Question is not part of the given form: {questionId}', [
+					'questionId' => $questionId
+				]);
+				throw new OCSBadRequestException('Question doesn\'t belong to given Form');
+			}
+			// Abort if a question is not part of the Parent Question.
+			if ($questions[$arrayKey]->getParentQuestionId() !== $parentQuestionId) {
+				$this->logger->debug('This Question is not part of the given parent question: {parentQuestionId}', [
+					'parentQuestionId' => $parentQuestionId
+				]);
+				throw new OCSBadRequestException('Question doesn\'t belong to given Parent Question');
+			}
+
+			// Abort if a question is not part of the Branch.
+			if ($questions[$arrayKey]->getBranchId() !== $branchId) {
+				$this->logger->debug('This Question is not part of the given branch: {branchId}', [
+					'branchId' => $branchId
+				]);
+				throw new OCSBadRequestException('Question doesn\'t belong to given Branch');
+			}
+
 			// Abort if a question is already marked as deleted (order==0)
 			$oldOrder = $questions[$arrayKey]->getOrder();
 			if ($oldOrder === 0) {
@@ -1312,12 +1541,14 @@ public function getSubmissions(int $formId, ?string $query = null, ?int $limit =
 		foreach ($this->formsService->getQuestions($formId) as $question) {
 			$questions[$question['id']] = $question;
 		}
+		// Answers of subquestions get the name of their subquestion
+		$questionNames = array_column(FormsService::flattenQuestions(array_values($questions)), 'name', 'id');
 
 		// Append Display Names
-		$submissions = array_map(function (array $submission) use ($questions) {
+		$submissions = array_map(function (array $submission) use ($questionNames) {
 			if (!empty($submission['answers'])) {
-				$submission['answers'] = array_map(function (array $answer) use ($questions) {
-					$name = $questions[$answer['questionId']]['name'] ?? null;
+				$submission['answers'] = array_map(function (array $answer) use ($questionNames) {
+					$name = $questionNames[$answer['questionId']] ?? null;
 					if ($name) {
 						$answer['questionName'] = $name;
 					}
@@ -1865,6 +2096,88 @@ public function uploadFiles(int $formId, int $questionId, string $shareHash = ''
 
 	// private functions
 
+	/**
+	 * Copy the options of a question to another question
+	 *
+	 * @return array<int, Option> the inserted options, keyed by the id of the option they were copied from
+	 */
+	private function copyOptions(int $fromQuestionId, int $toQuestionId): array {
+		$copiedOptions = [];
+		foreach ($this->optionMapper->findByQuestion($fromQuestionId) as $option) {
+			$optionData = $option->read();
+			unset($optionData['id']);
+			$optionData['questionId'] = $toQuestionId;
+			$copiedOptions[$option->getId()] = $this->optionMapper->insert(Option::fromParams($optionData));
+		}
+		return $copiedOptions;
+	}
+
+	/**
+	 * Copy the subquestions of a conditional question and point the branch conditions of the copy to its own options
+	 *
+	 * @param array<int, Option> $copiedOptions the options of the copy, keyed by the id of the option they were copied from
+	 */
+	private function copyConditionalBranches(Question $source, Question $copy, array $copiedOptions): void {
+		$optionIdMap = array_map(static fn (Option $option) => $option->getId(), $copiedOptions);
+		$copy->setExtraSettings(FormsService::mapConditionOptionIds($copy->getExtraSettings(), $optionIdMap));
+		$this->questionMapper->update($copy);
+
+		foreach ($this->questionMapper->findByParentQuestion($source->getId()) as $subQuestion) {
+			if ($subQuestion->getFormId() !== $source->getFormId()) {
+				continue;
+			}
+			$subQuestionData = $subQuestion->read();
+			unset($subQuestionData['id']);
+			$subQuestionData['formId'] = $copy->getFormId();
+			$subQuestionData['parentQuestionId'] = $copy->getId();
+			$newSubQuestion = Question::fromParams($subQuestionData);
+			$this->questionMapper->insert($newSubQuestion);
+			$this->copyOptions($subQuestion->getId(), $newSubQuestion->getId());
+		}
+	}
+
+	/**
+	 * Drop subquestion snapshots from the branches and delete the subquestions of removed branches
+	 *
+	 * @param array<string, mixed> $extraSettings the new extra settings of the conditional question
+	 * @return array<string, mixed> the extra settings to store
+	 */
+	private function updateConditionalBranches(Form $form, Question $question, array $extraSettings): array {
+		$branchIds = [];
+		foreach ($extraSettings['branches'] as $branchIndex => $branch) {
+			unset($extraSettings['branches'][$branchIndex]['subQuestions']);
+			$branchIds[] = $branch['id'] ?? null;
+		}
+
+		foreach ($this->questionMapper->findByParentQuestion($question->getId()) as $subQuestion) {
+			if (!in_array($subQuestion->getBranchId(), $branchIds, true)) {
+				$this->deleteSubQuestion($form, $subQuestion);
+			}
+		}
+
+		return $extraSettings;
+	}
+
+	/**
+	 * Soft-delete a subquestion whose conditional question or branch is deleted, like a deleted question
+	 */
+	private function deleteSubQuestion(Form $form, Question $subQuestion): void {
+		$subQuestion->setOrder(0);
+		$this->questionMapper->update($subQuestion);
+
+		if ($subQuestion->getType() === Constants::ANSWER_TYPE_FILE) {
+			$this->jobList->add(DeleteQuestionFoldersJob::class, [
+				'formId' => $form->getId(),
+				'questionId' => $subQuestion->getId(),
+				'ownerId' => $form->getOwnerId(),
+			]);
+		}
+
+		if ($form->getConfirmationEmailQuestionId() === $subQuestion->getId()) {
+			$form->setConfirmationEmailQuestionId(null);
+		}
+	}
+
 	/**
 	 * Insert answers for a question
 	 *
@@ -1890,13 +2203,18 @@ private function storeAnswersForQuestion(Form $form, $submissionId, array $quest
 			return;
 		}
 
+		// Special handling for conditional questions
+		if ($question['type'] === Constants::ANSWER_TYPE_CONDITIONAL) {
+			$this->storeConditionalAnswer($form, $submissionId, $question, $answerArray);
+			return;
+		}
+
 		foreach ($answerArray as $answer) {
 			$answerEntity = new Answer();
 			$answerEntity->setSubmissionId($submissionId);
 			$answerEntity->setQuestionId($question['id']);
 
 			$answerText = '';
-			$uploadedFile = null;
 			// Are we using answer ids as values
 			if (in_array($question['type'], Constants::ANSWER_TYPES_PREDEFINED) && $question['type'] !== Constants::ANSWER_TYPE_LINEARSCALE) {
 				// Search corresponding option, skip processing if not found
@@ -1907,28 +2225,7 @@ private function storeAnswersForQuestion(Form $form, $submissionId, array $quest
 					$answerText = str_replace(Constants::QUESTION_EXTRASETTINGS_OTHER_PREFIX, '', $answer);
 				}
 			} elseif ($question['type'] === Constants::ANSWER_TYPE_FILE) {
-				$uploadedFile = $this->uploadedFileMapper->getForSubmission(
-					(int)$answer['uploadedFileId'],
-					$form->getId(),
-					$question['id'],
-					$answer['uploadToken'] ?? '',
-				);
-				$answerEntity->setFileId($uploadedFile->getFileId());
-
-				$userFolder = $this->rootFolder->getUserFolder($form->getOwnerId());
-				$path = $this->formsService->getUploadedFilePath($form, $submissionId, $question['id'], $question['name'], $question['text']);
-
-				if ($userFolder->nodeExists($path)) {
-					$folder = $userFolder->get($path);
-				} else {
-					$folder = $userFolder->newFolder($path);
-				}
-				/** @var Folder $folder */
-				$file = $userFolder->getById($uploadedFile->getFileId())[0];
-				$name = $folder->getNonExistingName($file->getName());
-				$file->move($folder->getPath() . '/' . $name);
-
-				$answerText = $name;
+				$answerText = $this->storeFileAnswer($form, $submissionId, $question, $answer, $answerEntity);
 			} else {
 				$answerText = $answer; // Not a multiple-question, answerText is given answer
 			}
@@ -1939,8 +2236,71 @@ private function storeAnswersForQuestion(Form $form, $submissionId, array $quest
 
 			$answerEntity->setText($answerText);
 			$this->answerMapper->insert($answerEntity);
-			if ($uploadedFile) {
-				$this->uploadedFileMapper->delete($uploadedFile);
+		}
+	}
+
+	/**
+	 * Store a file answer by moving the uploaded file to the submission folder.
+	 *
+	 * @param array $question The file question
+	 * @param array{uploadedFileId: int|string, fileName?: string, uploadToken?: string} $answer The uploaded file answer
+	 */
+	private function storeFileAnswer(Form $form, int $submissionId, array $question, array $answer, Answer $answerEntity): string {
+		$uploadedFile = $this->uploadedFileMapper->getForSubmission(
+			(int)$answer['uploadedFileId'],
+			$form->getId(),
+			$question['id'],
+			$answer['uploadToken'] ?? '',
+		);
+		$answerEntity->setFileId($uploadedFile->getFileId());
+
+		$userFolder = $this->rootFolder->getUserFolder($form->getOwnerId());
+		$path = $this->formsService->getUploadedFilePath($form, $submissionId, $question['id'], $question['name'], $question['text']);
+
+		if ($userFolder->nodeExists($path)) {
+			$folder = $userFolder->get($path);
+		} else {
+			$folder = $userFolder->newFolder($path);
+		}
+		/** @var Folder $folder */
+
+		$files = $userFolder->getById($uploadedFile->getFileId());
+		if (empty($files)) {
+			throw new OCSBadRequestException('Uploaded file not found in storage.');
+		}
+		$file = $files[0];
+		$name = $folder->getNonExistingName($file->getName());
+		$file->move($folder->getPath() . '/' . $name);
+		$this->uploadedFileMapper->delete($uploadedFile);
+
+		return $name;
+	}
+
+	/**
+	 * Store answers for a conditional question
+	 *
+	 * Conditional answers have the structure:
+	 * - trigger: array of trigger answer values (option IDs for predefined types, or text)
+	 * - subQuestions: array of subquestion answers keyed by subquestion ID
+	 *
+	 * @param Form $form
+	 * @param int $submissionId
+	 * @param array $question The conditional question
+	 * @param array $answerData The conditional answer data
+	 */
+	private function storeConditionalAnswer(Form $form, int $submissionId, array $question, array $answerData): void {
+		[$triggerAnswers, $subQuestionAnswers] = SubmissionService::splitConditionalAnswer($answerData);
+
+		// The trigger is stored like a regular question of the trigger type
+		$this->storeAnswersForQuestion($form, $submissionId, SubmissionService::getTriggerQuestion($question), $triggerAnswers);
+
+		// Store subquestion answers only for the branches the trigger activated
+		foreach ($this->submissionService->getActiveBranches($question, $triggerAnswers) as $branch) {
+			foreach ($branch['subQuestions'] ?? [] as $subQuestion) {
+				$subAnswers = $subQuestionAnswers[$subQuestion['id']] ?? [];
+				if (!empty($subAnswers)) {
+					$this->storeAnswersForQuestion($form, $submissionId, $subQuestion, (array)$subAnswers);
+				}
 			}
 		}
 	}
diff --git a/lib/Db/Question.php b/lib/Db/Question.php
index 05355b95f9..da99ce3dfd 100644
--- a/lib/Db/Question.php
+++ b/lib/Db/Question.php
@@ -3,7 +3,7 @@
 declare(strict_types=1);
 
 /**
- * SPDX-FileCopyrightText: 2019 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2019-2026 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
@@ -21,9 +21,9 @@
  * @method void setOrder(integer $value)
  * @psalm-method FormsQuestionType getType()
  * @method string getType()
- * @psalm-method 'date'|'datetime'|'dropdown'|'file'|'long'|'multiple'|'multiple_unique'|'short'|'time' getType()
+ * @psalm-method 'color'|'conditional'|'date'|'datetime'|'dropdown'|'file'|'long'|'multiple'|'multiple_unique'|'short'|'time' getType()
  * @method void setType(string $value)
- * @psalm-method void setType('date'|'datetime'|'dropdown'|'file'|'long'|'multiple'|'multiple_unique'|'short'|'time' $value)
+ * @psalm-method void setType('color'|'conditional'|'date'|'datetime'|'dropdown'|'file'|'long'|'multiple'|'multiple_unique'|'short'|'time' $value)
  * @method bool getIsRequired()
  * @method void setIsRequired(bool $value)
  * @method string getText()
@@ -32,6 +32,10 @@
  * @method void setDescription(string $value)
  * @method string getName()
  * @method void setName(string $value)
+ * @method ?int getParentQuestionId()
+ * @method void setParentQuestionId(?int $value)
+ * @method ?string getBranchId()
+ * @method void setBranchId(?string $value)
  */
 class Question extends Entity {
 	protected $formId;
@@ -42,6 +46,8 @@ class Question extends Entity {
 	protected $name;
 	protected $description;
 	protected $extraSettingsJson;
+	protected $parentQuestionId;
+	protected $branchId;
 
 	public function __construct() {
 		$this->addType('formId', 'integer');
@@ -51,6 +57,8 @@ public function __construct() {
 		$this->addType('text', 'string');
 		$this->addType('description', 'string');
 		$this->addType('name', 'string');
+		$this->addType('parentQuestionId', 'integer');
+		$this->addType('branchId', 'string');
 	}
 
 	/**
@@ -85,6 +93,8 @@ public function setExtraSettings(array $extraSettings): void {
 	 *    name: string,
 	 *    description: string,
 	 *    extraSettings: FormsQuestionExtraSettings,
+	 *    parentQuestionId: ?int,
+	 *    branchId: ?string,
 	 *  }
 	 */
 	public function read(): array {
@@ -98,6 +108,8 @@ public function read(): array {
 			'name' => (string)$this->getName(),
 			'description' => (string)$this->getDescription(),
 			'extraSettings' => $this->getExtraSettings(),
+			'parentQuestionId' => $this->getParentQuestionId(),
+			'branchId' => $this->getBranchId(),
 		];
 	}
 
diff --git a/lib/Db/QuestionMapper.php b/lib/Db/QuestionMapper.php
index c705ac3c1e..a0679ce639 100644
--- a/lib/Db/QuestionMapper.php
+++ b/lib/Db/QuestionMapper.php
@@ -1,7 +1,7 @@
 <?php
 
 /**
- * SPDX-FileCopyrightText: 2019 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2019-2026 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
@@ -28,7 +28,7 @@ public function __construct(
 	 * @throws DoesNotExistException if not found
 	 * @return Question[]
 	 */
-	public function findByForm(int $formId, bool $loadDeleted = false): array {
+	public function findByForm(int $formId, bool $loadDeleted = false, bool $loadSubquestions = false): array {
 		$qb = $this->db->getQueryBuilder();
 
 		$qb->select('*')
@@ -37,6 +37,13 @@ public function findByForm(int $formId, bool $loadDeleted = false): array {
 				$qb->expr()->eq('form_id', $qb->createNamedParameter($formId, IQueryBuilder::PARAM_INT))
 			);
 
+		if (!$loadSubquestions) {
+			// Only load top-level questions (not subquestions of conditional questions)
+			$qb->andWhere(
+				$qb->expr()->isNull('parent_question_id')
+			);
+		}
+
 		if (!$loadDeleted) {
 			// Don't load questions, that are marked as deleted (marked by order==0).
 			$qb->andWhere(
@@ -50,14 +57,68 @@ public function findByForm(int $formId, bool $loadDeleted = false): array {
 		return $this->findEntities($qb);
 	}
 
+	/**
+	 * Find subquestions belonging to a parent conditional question
+	 *
+	 * @param int $parentQuestionId The ID of the parent conditional question
+	 * @param bool $loadDeleted Whether to include soft-deleted questions
+	 * @return Question[]
+	 */
+	public function findByParentQuestion(int $parentQuestionId, bool $loadDeleted = false): array {
+		$qb = $this->db->getQueryBuilder();
+
+		$qb->select('*')
+			->from($this->getTableName())
+			->where(
+				$qb->expr()->eq('parent_question_id', $qb->createNamedParameter($parentQuestionId, IQueryBuilder::PARAM_INT))
+			);
+
+		if (!$loadDeleted) {
+			$qb->andWhere(
+				$qb->expr()->neq('order', $qb->createNamedParameter(0, IQueryBuilder::PARAM_INT))
+			);
+		}
+
+		// Sort by order within the conditional question
+		$qb->orderBy('order');
+
+		return $this->findEntities($qb);
+	}
+
+	/**
+	 * Find subquestions belonging to a specific branch of a conditional question
+	 *
+	 * @param int $parentQuestionId The ID of the parent conditional question
+	 * @param string $branchId The branch identifier
+	 * @return Question[]
+	 */
+	public function findByBranch(int $parentQuestionId, string $branchId): array {
+		$qb = $this->db->getQueryBuilder();
+
+		$qb->select('*')
+			->from($this->getTableName())
+			->where(
+				$qb->expr()->eq('parent_question_id', $qb->createNamedParameter($parentQuestionId, IQueryBuilder::PARAM_INT))
+			)
+			->andWhere(
+				$qb->expr()->eq('branch_id', $qb->createNamedParameter($branchId))
+			)
+			->andWhere(
+				$qb->expr()->neq('order', $qb->createNamedParameter(0, IQueryBuilder::PARAM_INT))
+			)
+			->orderBy('order');
+
+		return $this->findEntities($qb);
+	}
+
 	/**
 	 * @param int $formId
 	 */
 	public function deleteByForm(int $formId): void {
 		$qb = $this->db->getQueryBuilder();
 
-		// First delete corresponding options.
-		$questionEntities = $this->findByForm($formId, true); // findByForm - loadDeleted=true
+		// First delete corresponding options, of subquestions as well.
+		$questionEntities = $this->findByForm($formId, true, true); // findByForm - loadDeleted=true, loadSubquestions=true
 		foreach ($questionEntities as $questionEntity) {
 			$this->optionMapper->deleteByQuestion($questionEntity->id);
 		}
diff --git a/lib/FormsMigrator.php b/lib/FormsMigrator.php
index b0fc92855e..82537282f1 100644
--- a/lib/FormsMigrator.php
+++ b/lib/FormsMigrator.php
@@ -66,7 +66,8 @@ public function export(IUser $user, IExportDestination $exportDestination, Outpu
 			$forms = $this->formMapper->findAllByOwnerId($user->getUID());
 			foreach ($forms as $form) {
 				$formData = $form->read();
-				$formData['questions'] = $this->formsService->getQuestions($formData['id']);
+				// Subquestions are exported as questions of their own, like they are stored
+				$formData['questions'] = FormsService::flattenQuestions($this->formsService->getQuestions($formData['id']));
 				$formData['submissions'] = $this->submissionService->getSubmissions($formData['id']);
 
 				// Unset ids and hash as we will anyways create new ones on import. UID is known through export.
@@ -77,7 +78,7 @@ public function export(IUser $user, IExportDestination $exportDestination, Outpu
 					// Do NOT unset ID of question here, as it is necessary for answers.
 					unset($formData['questions'][$qKey]['formId']);
 					foreach ($question['options'] as $oKey => $option) {
-						unset($formData['questions'][$qKey]['options'][$oKey]['id']);
+						// Do NOT unset ID of option here, as it is necessary for the conditions of conditional questions.
 						unset($formData['questions'][$qKey]['options'][$oKey]['questionId']);
 					}
 				}
@@ -164,7 +165,15 @@ public function import(IUser $user, IImportSource $importSource, OutputInterface
 				$this->formMapper->insert($form);
 
 				$questionIdMap = [];
+				$optionIdMap = [];
+				$conditionalQuestions = [];
 				foreach ($formData['questions'] as $questionData) {
+					// Subquestions follow their conditional question
+					$parentQuestionId = $questionData['parentQuestionId'] ?? null;
+					if ($parentQuestionId !== null && !isset($questionIdMap[$parentQuestionId])) {
+						continue;
+					}
+
 					$question = new Question();
 					$question->setFormId($form->getId());
 					$question->setOrder($questionData['order']);
@@ -173,6 +182,10 @@ public function import(IUser $user, IImportSource $importSource, OutputInterface
 					$question->setText($questionData['text']);
 					$question->setDescription($questionData['description']);
 					$question->setExtraSettings($questionData['extraSettings']);
+					if ($parentQuestionId !== null) {
+						$question->setParentQuestionId($questionIdMap[$parentQuestionId]);
+						$question->setBranchId($questionData['branchId'] ?? null);
+					}
 
 					$this->questionMapper->insert($question);
 
@@ -185,9 +198,24 @@ public function import(IUser $user, IImportSource $importSource, OutputInterface
 						$option->setText($optionData['text']);
 
 						$this->optionMapper->insert($option);
+
+						// Store OptionId to map the conditions of conditional questions.
+						if (isset($optionData['id'])) {
+							$optionIdMap[$optionData['id']] = $option->getId();
+						}
+					}
+
+					if ($questionData['type'] === Constants::ANSWER_TYPE_CONDITIONAL) {
+						$conditionalQuestions[] = $question;
 					}
 				}
 
+				// The branch conditions refer to the imported options
+				foreach ($conditionalQuestions as $question) {
+					$question->setExtraSettings(FormsService::mapConditionOptionIds($question->getExtraSettings(), $optionIdMap));
+					$this->questionMapper->update($question);
+				}
+
 				if (($formData['confirmationEmailQuestionId'] ?? null) !== null
 					&& isset($questionIdMap[$formData['confirmationEmailQuestionId']])) {
 					$form->setConfirmationEmailQuestionId($questionIdMap[$formData['confirmationEmailQuestionId']]);
@@ -203,6 +231,11 @@ public function import(IUser $user, IImportSource $importSource, OutputInterface
 					$this->submissionMapper->insert($submission);
 
 					foreach ($submissionData['answers'] as $answerData) {
+						// Answers of deleted questions are exported, the questions are not
+						if (!array_key_exists($answerData['questionId'], $questionIdMap)) {
+							continue;
+						}
+
 						$answer = new Answer();
 						$answer->setSubmissionId($submission->getId());
 						$answer->setQuestionId($questionIdMap[$answerData['questionId']]);
diff --git a/lib/Migration/Version050500Date20261104000000.php b/lib/Migration/Version050500Date20261104000000.php
new file mode 100644
index 0000000000..ee6bedcaec
--- /dev/null
+++ b/lib/Migration/Version050500Date20261104000000.php
@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Forms\Migration;
+
+use Closure;
+use OCP\DB\ISchemaWrapper;
+use OCP\DB\Types;
+use OCP\Migration\IOutput;
+use OCP\Migration\SimpleMigrationStep;
+
+/**
+ * Add parent_question_id and branch_id columns for conditional questions
+ */
+class Version050500Date20261104000000 extends SimpleMigrationStep {
+
+	/**
+	 * @param IOutput $output
+	 * @param Closure $schemaClosure The `\Closure` returns a `ISchemaWrapper`
+	 * @param array $options
+	 * @return null|ISchemaWrapper
+	 */
+	public function changeSchema(IOutput $output, Closure $schemaClosure, array $options): ?ISchemaWrapper {
+		/** @var ISchemaWrapper $schema */
+		$schema = $schemaClosure();
+		$table = $schema->getTable('forms_v2_questions');
+
+		// Add parent_question_id column - references parent conditional question
+		if (!$table->hasColumn('parent_question_id')) {
+			$table->addColumn('parent_question_id', Types::INTEGER, [
+				'notnull' => false,
+				'default' => null,
+				'comment' => 'ID of parent conditional question, null for top-level questions',
+			]);
+		}
+
+		// Add branch_id column - identifies which branch this subquestion belongs to
+		if (!$table->hasColumn('branch_id')) {
+			$table->addColumn('branch_id', Types::STRING, [
+				'notnull' => false,
+				'length' => 64,
+				'default' => null,
+				'comment' => 'Branch identifier within parent conditional question',
+			]);
+		}
+
+		// Add index for efficient lookup of subquestions by parent
+		if (!$table->hasIndex('forms_v2_q_parent_idx')) {
+			$table->addIndex(['parent_question_id'], 'forms_v2_q_parent_idx');
+		}
+
+		return $schema;
+	}
+}
diff --git a/lib/ResponseDefinitions.php b/lib/ResponseDefinitions.php
index 15ed973248..120921de48 100644
--- a/lib/ResponseDefinitions.php
+++ b/lib/ResponseDefinitions.php
@@ -42,9 +42,11 @@
  *   validationRegex?: string,
  *   validationType?: string,
  *   questionType?: string,
+ *   triggerType?: string,
+ *   branches?: list<array<string, mixed>>,
  * }
  *
- * @psalm-type FormsQuestionType = "dropdown"|"multiple"|"multiple_unique"|"date"|"time"|"short"|"long"|"file"|"datetime"|"grid"
+ * @psalm-type FormsQuestionType = "dropdown"|"multiple"|"multiple_unique"|"date"|"time"|"short"|"long"|"file"|"datetime"|"grid"|"color"|"conditional"
  * @psalm-type FormsQuestionGridCellType = "checkbox"|"number"|"radio"
  *
  * @psalm-type FormsQuestion = array{
@@ -59,6 +61,8 @@
  *   extraSettings: FormsQuestionExtraSettings|\stdClass,
  *   options: list<FormsOption>,
  *   accept: list<string>,
+ *   parentQuestionId?: ?int,
+ *   branchId?: ?string,
  * }
  *
  * @psalm-type FormsAnswer = array{
diff --git a/lib/Service/ConfirmationEmailService.php b/lib/Service/ConfirmationEmailService.php
index dcdb85b3c0..55e254dd56 100644
--- a/lib/Service/ConfirmationEmailService.php
+++ b/lib/Service/ConfirmationEmailService.php
@@ -129,7 +129,8 @@ public function validateRecipientQuestionId(Form $form, mixed $recipientId): voi
 	private function loadQuestions(int $formId): array {
 		$questions = [];
 		try {
-			foreach ($this->questionMapper->findByForm($formId) as $entity) {
+			// Subquestions can be placeholders or the recipient as well
+			foreach ($this->questionMapper->findByForm($formId, false, true) as $entity) {
 				$questions[] = $entity->read();
 			}
 		} catch (\Exception $e) {
diff --git a/lib/Service/FormsService.php b/lib/Service/FormsService.php
index 197ababbcb..bc66665627 100644
--- a/lib/Service/FormsService.php
+++ b/lib/Service/FormsService.php
@@ -1,7 +1,7 @@
 <?php
 
 /**
- * SPDX-FileCopyrightText: 2020 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2020-2026 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
@@ -86,73 +86,140 @@ public function generateFormHash(): string {
 	}
 
 	/**
-	 * Load options corresponding to question
+	 * Load questions corresponding to form
 	 *
-	 * @param integer $questionId
-	 * @return list<FormsOption>
+	 * @param integer $formId
+	 * @return list<FormsQuestion>
 	 */
-	private function getOptions(int $questionId): array {
-		$optionList = [];
+	public function getQuestions(int $formId): array {
 		try {
-			$optionEntities = $this->optionMapper->findByQuestion($questionId);
-			foreach ($optionEntities as $optionEntity) {
-				$optionList[] = $optionEntity->read();
-			}
+			// Top-level questions and subquestions are loaded at once and sorted by order
+			$questionEntities = $this->questionMapper->findByForm($formId, false, true);
 		} catch (DoesNotExistException) {
-			//handle silently
-		} finally {
-			return $optionList;
+			return [];
 		}
+
+		$optionsByQuestion = $this->getOptionsByQuestion($questionEntities);
+		$subQuestionsByParent = [];
+		foreach ($questionEntities as $questionEntity) {
+			if ($questionEntity->getParentQuestionId() !== null) {
+				$subQuestionsByParent[$questionEntity->getParentQuestionId()][] = $questionEntity;
+			}
+		}
+
+		$questionList = [];
+		foreach ($questionEntities as $questionEntity) {
+			if ($questionEntity->getParentQuestionId() === null) {
+				$questionList[] = $this->formatQuestion($questionEntity, $optionsByQuestion, $subQuestionsByParent[$questionEntity->getId()] ?? []);
+			}
+		}
+		return $questionList;
 	}
 
 	/**
-	 * Load questions corresponding to form
+	 * List the subquestions of conditional questions after their conditional question instead of within its branches
 	 *
-	 * @param integer $formId
-	 * @return list<FormsQuestion>
+	 * @param list<array<string, mixed>> $questions questions as returned by getQuestions()
+	 * @return array<int, array<string, mixed>>
 	 */
-	public function getQuestions(int $formId): array {
-		$questionList = [];
-		try {
-			$questionEntities = $this->questionMapper->findByForm($formId);
+	public static function flattenQuestions(array $questions): array {
+		$flattened = [];
+		foreach ($questions as $question) {
+			$subQuestions = [];
+			// Empty extra settings can be an object
+			if (is_array($question['extraSettings'] ?? null)) {
+				foreach ($question['extraSettings']['branches'] ?? [] as $branchIndex => $branch) {
+					/** @var list<array<string, mixed>> $branchSubQuestions */
+					$branchSubQuestions = $branch['subQuestions'] ?? [];
+					array_push($subQuestions, ...$branchSubQuestions);
+					unset($question['extraSettings']['branches'][$branchIndex]['subQuestions']);
+				}
+			}
+			array_push($flattened, $question, ...$subQuestions);
+		}
+		return $flattened;
+	}
 
-			$questionIds = array_map(static fn (Question $question) => $question->getId(), $questionEntities);
-			$optionsByQuestion = [];
-			foreach ($this->optionMapper->findByQuestions($questionIds) as $optionEntity) {
-				$optionsByQuestion[$optionEntity->getQuestionId()][] = $optionEntity;
+	/**
+	 * Point the branch conditions of a conditional question to other options, e.g. those of a copy
+	 *
+	 * Subquestions are rows of their own, any snapshot of them in the branches is dropped.
+	 *
+	 * @param array<string, mixed> $extraSettings the extra settings of the conditional question
+	 * @param array<int, int> $optionIdMap the new option ids, keyed by the old ones
+	 * @return array<string, mixed>
+	 */
+	public static function mapConditionOptionIds(array $extraSettings, array $optionIdMap): array {
+		foreach ($extraSettings['branches'] ?? [] as $branchIndex => $branch) {
+			unset($extraSettings['branches'][$branchIndex]['subQuestions']);
+			foreach ($branch['conditions'] ?? [] as $conditionIndex => $condition) {
+				if (isset($condition['optionId'])) {
+					$extraSettings['branches'][$branchIndex]['conditions'][$conditionIndex]['optionId'] = $optionIdMap[$condition['optionId']] ?? $condition['optionId'];
+				}
 			}
+		}
+		return $extraSettings;
+	}
 
-			foreach ($questionEntities as $questionEntity) {
-				$question = $questionEntity->read();
-				$question['options'] = array_map(
-					static fn (Option $option) => $option->read(),
-					$optionsByQuestion[$question['id']] ?? []
-				);
-				$question['accept'] = [];
-				if ($question['type'] === Constants::ANSWER_TYPE_FILE) {
-					if ($question['extraSettings']['allowedFileTypes'] ?? null) {
-						$question['accept'] = array_map(fn (string $fileType) => str_contains($fileType, '/') ? $fileType : $fileType . '/*', $question['extraSettings']['allowedFileTypes']);
-					}
+	/**
+	 * Load the options of the given questions at once
+	 *
+	 * @param Question[] $questionEntities
+	 * @return array<int, list<Option>> the options keyed by question id
+	 */
+	private function getOptionsByQuestion(array $questionEntities): array {
+		$questionIds = array_map(static fn (Question $question) => $question->getId(), $questionEntities);
+		$optionsByQuestion = [];
+		foreach ($this->optionMapper->findByQuestions($questionIds) as $optionEntity) {
+			$optionsByQuestion[(int)$optionEntity->getQuestionId()][] = $optionEntity;
+		}
+		return $optionsByQuestion;
+	}
 
-					if ($question['extraSettings']['allowedFileExtensions'] ?? null) {
-						foreach ($question['extraSettings']['allowedFileExtensions'] as $extension) {
-							$question['accept'][] = '.' . $extension;
-						}
-					}
-				}
+	/**
+	 * Build the API representation of a question
+	 *
+	 * @param array<int, list<Option>> $optionsByQuestion the options keyed by question id
+	 * @param Question[] $subQuestionEntities the subquestions, if the question is a conditional question
+	 * @return FormsQuestion
+	 */
+	private function formatQuestion(Question $questionEntity, array $optionsByQuestion, array $subQuestionEntities = []): array {
+		$question = $questionEntity->read();
+		$question['options'] = array_map(static fn (Option $option) => $option->read(), $optionsByQuestion[$question['id']] ?? []);
+		$question['accept'] = [];
+		if ($question['type'] === Constants::ANSWER_TYPE_FILE) {
+			if ($question['extraSettings']['allowedFileTypes'] ?? null) {
+				$question['accept'] = array_map(fn (string $fileType) => str_contains($fileType, '/') ? $fileType : $fileType . '/*', $question['extraSettings']['allowedFileTypes']);
+			}
 
-				// Set `isRequired` if minimum options limit is set
-				if ($question['type'] === Constants::ANSWER_TYPE_MULTIPLE && ($question['extraSettings']['optionsLimitMin'] ?? 0) > 0) {
-					$question['isRequired'] = true;
+			if ($question['extraSettings']['allowedFileExtensions'] ?? null) {
+				foreach ($question['extraSettings']['allowedFileExtensions'] as $extension) {
+					$question['accept'][] = '.' . $extension;
 				}
+			}
+		}
+
+		// Set `isRequired` if minimum options limit is set
+		if ($question['type'] === Constants::ANSWER_TYPE_MULTIPLE && ($question['extraSettings']['optionsLimitMin'] ?? 0) > 0) {
+			$question['isRequired'] = true;
+		}
 
-				$questionList[] = $question;
+		// Attach the subquestions of conditional questions to their branches
+		if ($question['type'] === Constants::ANSWER_TYPE_CONDITIONAL && is_array($question['extraSettings']['branches'] ?? null)) {
+			$subQuestionsByBranch = [];
+			foreach ($subQuestionEntities as $subQuestionEntity) {
+				// Subquestions always belong to the form of their parent
+				if ($subQuestionEntity->getFormId() === $questionEntity->getFormId()) {
+					$subQuestionsByBranch[$subQuestionEntity->getBranchId()][] = $this->formatQuestion($subQuestionEntity, $optionsByQuestion);
+				}
 			}
-		} catch (DoesNotExistException) {
-			//handle silently
-		} finally {
-			return $questionList;
+			$question['extraSettings']['branches'] = array_map(
+				static fn (array $branch) => [...$branch, 'subQuestions' => $subQuestionsByBranch[$branch['id'] ?? ''] ?? []],
+				$question['extraSettings']['branches'],
+			);
 		}
+
+		return $question;
 	}
 
 	/**
@@ -164,24 +231,16 @@ public function getQuestions(int $formId): array {
 	public function getQuestion(int $questionId): ?array {
 		try {
 			$questionEntity = $this->questionMapper->findById($questionId);
-			$question = $questionEntity->read();
-			$question['options'] = $this->getOptions($question['id']);
-			$question['accept'] = [];
-			if ($question['type'] === Constants::ANSWER_TYPE_FILE) {
-				if ($question['extraSettings']['allowedFileTypes'] ?? null) {
-					$question['accept'] = array_map(fn (string $fileType) => str_contains($fileType, '/') ? $fileType : $fileType . '/*', $question['extraSettings']['allowedFileTypes']);
-				}
-
-				if ($question['extraSettings']['allowedFileExtensions'] ?? null) {
-					foreach ($question['extraSettings']['allowedFileExtensions'] as $extension) {
-						$question['accept'][] = '.' . $extension;
-					}
-				}
-			}
-			return $question;
 		} catch (DoesNotExistException) {
 			return null;
 		}
+
+		$subQuestionEntities = $questionEntity->getType() === Constants::ANSWER_TYPE_CONDITIONAL
+			? $this->questionMapper->findByParentQuestion($questionId)
+			: [];
+		$optionsByQuestion = $this->getOptionsByQuestion(array_merge([$questionEntity], $subQuestionEntities));
+
+		return $this->formatQuestion($questionEntity, $optionsByQuestion, $subQuestionEntities);
 	}
 
 	/**
@@ -852,6 +911,57 @@ public function notifyNewSubmission(Form $form, Submission $submission): void {
 		$this->confirmationEmailService->send($form, $submission);
 	}
 
+	/**
+	 * Check that a regular expression is enclosed in slashes, only uses modifiers supported by PHP *and* JS and compiles
+	 */
+	private function isValidRegex(string $regex): bool {
+		// general pattern of a valid regex
+		$VALID_REGEX = '/^\/(.+)\/([smi]{0,3})$/';
+		// pattern to look for unescaped slashes
+		$REGEX_UNESCAPED_SLASHES = '/(?<=(^|[^\\\\]))(\\\\\\\\)*\\//';
+
+		$matches = [];
+		// only pattern with delimiters and supported modifiers (by PHP *and* JS)
+		if (@preg_match($VALID_REGEX, $regex, $matches) !== 1) {
+			return false;
+		}
+
+		// We use slashes as delimters, so unescaped slashes within the pattern are **not** allowed
+		if (@preg_match($REGEX_UNESCAPED_SLASHES, $matches[1]) === 1) {
+			return false;
+		}
+
+		// Try to compile the given pattern, `preg_match` will return false if the pattern is invalid
+		return @preg_match($regex, 'some string') !== false;
+	}
+
+	/**
+	 * Check the conditions of a conditional question branch against its trigger type
+	 *
+	 * @param string $triggerType the type of the trigger question
+	 * @param array $conditions the conditions of the branch
+	 */
+	private function areBranchConditionsValid(string $triggerType, array $conditions): bool {
+		$allowedTypes = Constants::CONDITIONAL_TRIGGER_TYPES[$triggerType] ?? [];
+		foreach ($conditions as $condition) {
+			if (!is_array($condition)) {
+				return false;
+			}
+			if (isset($condition['type']) && !in_array($condition['type'], $allowedTypes, true)) {
+				return false;
+			}
+			if (isset($condition['optionId']) && !is_int($condition['optionId'])) {
+				return false;
+			}
+			foreach (['value', 'min', 'max'] as $key) {
+				if (isset($condition[$key]) && !is_scalar($condition[$key])) {
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+
 	/**
 	 * Return shares of a form shared with given user
 	 *
@@ -900,19 +1010,28 @@ public function areExtraSettingsValid(array $extraSettings, string $questionType
 			return true;
 		}
 
-		// Ensure only allowed keys are set
-		$allowed = match ($questionType) {
+		// Map allowed options to answer type
+		$extraSettingsMap = [
 			Constants::ANSWER_TYPE_DROPDOWN => Constants::EXTRA_SETTINGS_DROPDOWN,
-			Constants::ANSWER_TYPE_MULTIPLE, Constants::ANSWER_TYPE_MULTIPLEUNIQUE => Constants::EXTRA_SETTINGS_MULTIPLE,
+			Constants::ANSWER_TYPE_MULTIPLE => Constants::EXTRA_SETTINGS_MULTIPLE,
+			Constants::ANSWER_TYPE_MULTIPLEUNIQUE => Constants::EXTRA_SETTINGS_MULTIPLE,
 			Constants::ANSWER_TYPE_SHORT => Constants::EXTRA_SETTINGS_SHORT,
 			Constants::ANSWER_TYPE_FILE => Constants::EXTRA_SETTINGS_FILE,
 			Constants::ANSWER_TYPE_DATE => Constants::EXTRA_SETTINGS_DATE,
 			Constants::ANSWER_TYPE_GRID => Constants::EXTRA_SETTINGS_GRID,
-			Constants::ANSWER_TYPE_RANKING => Constants::EXTRA_SETTINGS_RANKING,
 			Constants::ANSWER_TYPE_TIME => Constants::EXTRA_SETTINGS_TIME,
 			Constants::ANSWER_TYPE_LINEARSCALE => Constants::EXTRA_SETTINGS_LINEARSCALE,
-			default => [],
-		};
+			Constants::ANSWER_TYPE_RANKING => Constants::EXTRA_SETTINGS_RANKING,
+			Constants::ANSWER_TYPE_CONDITIONAL => Constants::EXTRA_SETTINGS_CONDITIONAL,
+		];
+
+		// Get triggertype if is conditional
+		$triggerType = $extraSettings['triggerType'] ?? null;
+		if (is_string($triggerType) && isset($extraSettingsMap[$triggerType])) {
+			$extraSettingsMap[Constants::ANSWER_TYPE_CONDITIONAL] += $extraSettingsMap[$triggerType];
+		}
+		// Ensure only allowed keys are set
+		$allowed = $extraSettingsMap[$questionType] ?? [];
 		// Number of keys in extraSettings but not in allowed (but not the other way round)
 		$diff = array_diff(array_keys($extraSettings), array_keys($allowed));
 		if (count($diff) > 0) {
@@ -1022,35 +1141,65 @@ public function areExtraSettingsValid(array $extraSettings, string $questionType
 					return true;
 				}
 
-				// general pattern of a valid regex
-				$VALID_REGEX = '/^\/(.+)\/([smi]{0,3})$/';
-				// pattern to look for unescaped slashes
-				$REGEX_UNESCAPED_SLASHES = '/(?<=(^|[^\\\\]))(\\\\\\\\)*\\//';
+				if (!$this->isValidRegex($extraSettings['validationRegex'])) {
+					return false;
+				}
+			}
+
+			// Special handling of linear scale validation
+		} elseif ($questionType === Constants::ANSWER_TYPE_LINEARSCALE) {
+			// Ensure limits are sane
+			if (isset($extraSettings['optionsLowest']) && ($extraSettings['optionsLowest'] < 0 || $extraSettings['optionsLowest'] > 1)
+				|| isset($extraSettings['optionsHighest']) && ($extraSettings['optionsHighest'] < 2 || $extraSettings['optionsHighest'] > 10)) {
+				return false;
+			}
+		} elseif ($questionType === Constants::ANSWER_TYPE_CONDITIONAL) {
+			// Validate conditional question settings
+			if (!isset($extraSettings['triggerType']) || !is_string($extraSettings['triggerType'])) {
+				return false;
+			}
+
+			// Validate trigger type is a valid question type (and not nested conditional)
+			if (!array_key_exists($extraSettings['triggerType'], Constants::CONDITIONAL_TRIGGER_TYPES)) {
+				return false;
+			}
+
+			// Branches are required for conditional questions
+			if (!isset($extraSettings['branches']) || !is_array($extraSettings['branches'])) {
+				return false;
+			}
 
-				$matches = [];
-				// only pattern with delimiters and supported modifiers (by PHP *and* JS)
-				if (@preg_match($VALID_REGEX, $extraSettings['validationRegex'], $matches) !== 1) {
+			// Validate branches structure
+			$branchIds = [];
+			foreach ($extraSettings['branches'] as $branch) {
+				// Each branch must have a unique id that fits into the branch id of its subquestions
+				if (!isset($branch['id']) || !is_string($branch['id']) || $branch['id'] === ''
+					|| strlen($branch['id']) > 64 || isset($branchIds[$branch['id']])) {
 					return false;
 				}
+				$branchIds[$branch['id']] = true;
 
-				// We use slashes as delimters, so unescaped slashes within the pattern are **not** allowed
-				if (@preg_match($REGEX_UNESCAPED_SLASHES, $matches[1]) === 1) {
+				// Branches must have conditions array
+				if (!isset($branch['conditions']) || !is_array($branch['conditions'])) {
 					return false;
 				}
 
-				// Try to compile the given pattern, `preg_match` will return false if the pattern is invalid
-				if (@preg_match($extraSettings['validationRegex'], 'some string') === false) {
+				if (!$this->areBranchConditionsValid($extraSettings['triggerType'], $branch['conditions'])) {
 					return false;
 				}
 			}
 
-			// Special handling of linear scale validation
-		} elseif ($questionType === Constants::ANSWER_TYPE_LINEARSCALE) {
-			// Ensure limits are sane
-			if (isset($extraSettings['optionsLowest']) && ($extraSettings['optionsLowest'] < 0 || $extraSettings['optionsLowest'] > 1)
-				|| isset($extraSettings['optionsHighest']) && ($extraSettings['optionsHighest'] < 2 || $extraSettings['optionsHighest'] > 10)) {
-				return false;
+			$diff = array_diff(array_keys($extraSettings), array_keys(Constants::EXTRA_SETTINGS_CONDITIONAL));
+			// Handle options of triggerQuestion
+			if (count($diff) > 0 && isset($triggerType) && $triggerType !== '') {
+				$diffDict = [];
+				foreach ($diff as $k) {
+					$diffDict[$k] = $extraSettings[$k];
+				}
+				$valid = self::areExtraSettingsValid($diffDict, $triggerType);
+				return $valid;
 			}
+
 		}
 		return true;
 	}
diff --git a/lib/Service/SubmissionService.php b/lib/Service/SubmissionService.php
index 278fb28286..719f7582e7 100644
--- a/lib/Service/SubmissionService.php
+++ b/lib/Service/SubmissionService.php
@@ -1,7 +1,7 @@
 <?php
 
 /**
- * SPDX-FileCopyrightText: 2021 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2021-2026 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
@@ -241,7 +241,7 @@ public function getSubmissionsData(Form $form, string $fileFormat, ?File $file =
 		// Oldest first
 		$submissionEntities = array_reverse($submissionEntities);
 
-		$questions = $this->questionMapper->findByForm($form->getId());
+		$questions = $this->orderQuestionsForExport($this->questionMapper->findByForm($form->getId(), false, true));
 		$defaultTimeZone = $this->config->getSystemValueString('default_timezone', 'UTC');
 
 		if (!$this->currentUser) {
@@ -591,7 +591,7 @@ private function escapeCSV(string $value): string {
 	 * @param array $answers Array of the submitted answers
 	 * @param string $formOwnerId Owner of the form
 	 * @param int $formId Id of the form being submitted
-	 * @throw \InvalidArgumentException if validation failed
+	 * @throws \InvalidArgumentException if validation failed
 	 */
 	public function validateSubmission(array $questions, array $answers, string $formOwnerId, int $formId): void {
 		// Check by questions
@@ -599,6 +599,20 @@ public function validateSubmission(array $questions, array $answers, string $for
 			$questionId = $question['id'];
 			$questionAnswered = array_key_exists($questionId, $answers);
 
+			// Special handling for conditional questions
+			if ($question['type'] === Constants::ANSWER_TYPE_CONDITIONAL) {
+				// Check if required conditional has any answer
+				if ($question['isRequired'] && !$questionAnswered) {
+					throw new \InvalidArgumentException(sprintf('Question "%s" is required.', $question['text']));
+				}
+
+				// If answered, validate the conditional structure
+				if ($questionAnswered) {
+					$this->validateConditionalQuestion($question, $answers[$questionId], $formOwnerId, $formId);
+				}
+				continue;
+			}
+
 			// Check if all required questions have an answer
 			if ($question['isRequired']
 				&& (!$questionAnswered
@@ -687,8 +701,8 @@ public function validateSubmission(array $questions, array $answers, string $for
 						// Accept numeric strings like "46" from JSON payloads reliably (e.g. with hardening extensions enabled)
 						$answerId = is_int($answer) ? $answer : (is_string($answer) ? intval(trim($answer)) : null);
 
-						// Reject non-numeric / malformed values early
-						if ($answerId === null || (string)$answerId !== (string)intval($answerId)) {
+						// Reject non-numeric / malformed values early, other notations of an option id like "05" as well
+						if ($answerId === null || (string)$answerId !== (string)$answer) {
 							throw new \InvalidArgumentException(sprintf('Answer "%s" for question "%s" is not a valid option.', is_scalar($answer) ? (string)$answer : gettype($answer), $question['text']));
 						}
 
@@ -755,8 +769,9 @@ public function validateSubmission(array $questions, array $answers, string $for
 
 		// Check for excess answers
 		foreach ($answers as $id => $answerArray) {
-			// Search corresponding question, return false if not found
-			if (!in_array($id, array_column($questions, 'id'))) {
+			// Search corresponding question, return false if not found. Other notations of a question id like "1.0"
+			// would be stored for that question, but skip its validation.
+			if (!in_array($id, array_column($questions, 'id'), true)) {
 				throw new \InvalidArgumentException(sprintf('Answer for non-existent question with ID %d.', $id));
 			}
 		}
@@ -959,4 +974,181 @@ private function setCellValue(Worksheet $activeWorksheet, int $column, int $row,
 		$activeWorksheet->getCell([$column, $row])
 			->setValueExplicit($value, DataType::TYPE_STRING);
 	}
+
+	/**
+	 * Put the subquestions of each conditional question right after it, in branch order,
+	 * and leave out subquestions of branches that no longer exist
+	 *
+	 * @param Question[] $questions top-level questions and subquestions, sorted by order
+	 * @return list<Question>
+	 */
+	private function orderQuestionsForExport(array $questions): array {
+		$subQuestions = [];
+		foreach ($questions as $question) {
+			if ($question->getParentQuestionId() !== null) {
+				$subQuestions[$question->getParentQuestionId()][(string)$question->getBranchId()][] = $question;
+			}
+		}
+
+		$ordered = [];
+		foreach ($questions as $question) {
+			if ($question->getParentQuestionId() !== null) {
+				continue;
+			}
+			$ordered[] = $question;
+			if ($question->getType() === Constants::ANSWER_TYPE_CONDITIONAL) {
+				foreach ($question->getExtraSettings()['branches'] ?? [] as $branch) {
+					array_push($ordered, ...($subQuestions[$question->getId()][(string)($branch['id'] ?? '')] ?? []));
+				}
+			}
+		}
+		return $ordered;
+	}
+
+	/**
+	 * Validate conditional question answers
+	 *
+	 * Conditional questions have a special answer structure:
+	 * - trigger: array of trigger answer values
+	 * - subQuestions: array of subquestion answers keyed by subquestion ID
+	 *
+	 * @param array $question The conditional question
+	 * @param array $answerData The answer data for the conditional question
+	 * @param string $formOwnerId Owner of the form
+	 * @param int $formId Id of the form being submitted
+	 * @throws \InvalidArgumentException if validation failed
+	 */
+	private function validateConditionalQuestion(array $question, array $answerData, string $formOwnerId, int $formId): void {
+		if (empty($question['extraSettings']['triggerType'])) {
+			throw new \InvalidArgumentException(sprintf('Conditional question "%s" is missing trigger type configuration.', $question['text']));
+		}
+
+		[$triggerAnswer, $subQuestionAnswers] = self::splitConditionalAnswer($answerData);
+
+		// The trigger gets the same checks as a regular question of the trigger type
+		$triggerQuestion = self::getTriggerQuestion($question);
+		$this->validateSubmission([$triggerQuestion], $triggerAnswer === [] ? [] : [$triggerQuestion['id'] => $triggerAnswer], $formOwnerId, $formId);
+
+		// Only the subquestions of the active branches may be answered, with the full per-question rules
+		$subQuestions = [];
+		foreach ($this->getActiveBranches($question, $triggerAnswer) as $branch) {
+			array_push($subQuestions, ...($branch['subQuestions'] ?? []));
+		}
+		$this->validateSubmission($subQuestions, $subQuestionAnswers, $formOwnerId, $formId);
+	}
+
+	/**
+	 * Split the answer of a conditional question into the trigger answer and the subquestion answers
+	 *
+	 * @param array $answerData `{trigger: [...], subQuestions: {id: [...]}}`, or just the trigger answer
+	 * @return array{0: array, 1: array} the trigger answer and the subquestion answers keyed by subquestion id
+	 */
+	public static function splitConditionalAnswer(array $answerData): array {
+		if (!array_key_exists('trigger', $answerData) && !array_key_exists('subQuestions', $answerData)) {
+			$triggerAnswer = $answerData;
+			$subQuestionAnswers = [];
+		} else {
+			$triggerAnswer = $answerData['trigger'] ?? [];
+			$subQuestionAnswers = $answerData['subQuestions'] ?? [];
+		}
+
+		// Like the answer of a question, the trigger answer is a list of values, the branches are matched against it
+		if (!is_array($triggerAnswer) || !array_is_list($triggerAnswer) || !is_array($subQuestionAnswers)) {
+			throw new \InvalidArgumentException('Invalid answer for conditional question.');
+		}
+		foreach ($subQuestionAnswers as $subQuestionAnswer) {
+			if (!is_array($subQuestionAnswer)) {
+				throw new \InvalidArgumentException('Invalid answer for conditional question.');
+			}
+		}
+
+		return [$triggerAnswer, $subQuestionAnswers];
+	}
+
+	/**
+	 * Get the trigger of a conditional question as a regular question of the trigger type
+	 *
+	 * The trigger shares id, options and the remaining extra settings with the conditional question.
+	 *
+	 * @param array $question The conditional question
+	 * @return array The trigger question
+	 */
+	public static function getTriggerQuestion(array $question): array {
+		$extraSettings = $question['extraSettings'] ?? [];
+		$triggerType = $extraSettings['triggerType'] ?? '';
+		unset($extraSettings['triggerType'], $extraSettings['branches']);
+
+		return [
+			...$question,
+			'type' => $triggerType,
+			'extraSettings' => $extraSettings,
+		];
+	}
+
+	/**
+	 * Resolve the branch a conditional question's trigger answer activates
+	 *
+	 * @param array $question The conditional question
+	 * @param array $triggerAnswer The trigger answer values
+	 * @return array The active branches or empty array if none matches
+	 */
+	public function getActiveBranches(array $question, array $triggerAnswer): array {
+		$extraSettings = $question['extraSettings'] ?? [];
+		return $this->findActiveBranches(
+			$extraSettings['triggerType'] ?? '',
+			$triggerAnswer,
+			$extraSettings['branches'] ?? [],
+		);
+	}
+
+	/**
+	 * Find the active branches based on trigger answer
+	 *
+	 * @param string $triggerType The type of the trigger question
+	 * @param array $triggerAnswer The trigger answer values
+	 * @param array $branches The available branches
+	 * @return array The active branches or empty array if none matches
+	 */
+	private function findActiveBranches(string $triggerType, array $triggerAnswer, array $branches): array {
+		return array_filter($branches, function ($branch) use ($triggerType, $triggerAnswer) {
+			$conditions = $branch['conditions'] ?? [];
+			if (empty($conditions)) {
+				return false;
+			}
+			return $this->evaluateBranchConditions($triggerType, $triggerAnswer, $conditions);
+		});
+	}
+
+	/**
+	 * Evaluate if branch conditions match the trigger answer
+	 *
+	 * @param string $triggerType The type of the trigger question
+	 * @param array $triggerAnswer The trigger answer values
+	 * @param array $conditions The conditions to evaluate
+	 * @return bool True if conditions match
+	 */
+	private function evaluateBranchConditions(string $triggerType, array $triggerAnswer, array $conditions): bool {
+		// Option ids arrive as numbers or strings depending on the trigger component
+		$selectedOptionIds = array_map('strval', array_filter($triggerAnswer, 'is_scalar'));
+
+		// An unanswered trigger activates no branch
+		if ($triggerAnswer === [] || ($triggerAnswer[0] ?? '') === '') {
+			return false;
+		}
+
+		switch ($triggerType) {
+			case Constants::ANSWER_TYPE_MULTIPLEUNIQUE:
+			case Constants::ANSWER_TYPE_DROPDOWN:
+				// Single select: check if selected option matches any condition
+				foreach ($conditions as $condition) {
+					$optionId = $condition['optionId'] ?? null;
+					if (is_scalar($optionId) && in_array((string)$optionId, $selectedOptionIds, true)) {
+						return true;
+					}
+				}
+				return false;
+			default:
+				return false;
+		}
+	}
 }
diff --git a/openapi.json b/openapi.json
index 4336a8c924..7cc42b293f 100644
--- a/openapi.json
+++ b/openapi.json
@@ -484,6 +484,15 @@
                         "items": {
                             "type": "string"
                         }
+                    },
+                    "parentQuestionId": {
+                        "type": "integer",
+                        "format": "int64",
+                        "nullable": true
+                    },
+                    "branchId": {
+                        "type": "string",
+                        "nullable": true
                     }
                 }
             },
@@ -595,6 +604,18 @@
                     },
                     "questionType": {
                         "type": "string"
+                    },
+                    "triggerType": {
+                        "type": "string"
+                    },
+                    "branches": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "object"
+                            }
+                        }
                     }
                 }
             },
@@ -618,7 +639,9 @@
                     "long",
                     "file",
                     "datetime",
-                    "grid"
+                    "grid",
+                    "color",
+                    "conditional"
                 ]
             },
             "Share": {
@@ -1713,6 +1736,19 @@
                                         "default": null,
                                         "description": "(optional) id of the question that should be cloned"
                                     },
+                                    "parentQuestionId": {
+                                        "type": "integer",
+                                        "format": "int64",
+                                        "nullable": true,
+                                        "default": null,
+                                        "description": "(optional) id of the parent conditional question (for subquestions)"
+                                    },
+                                    "branchId": {
+                                        "type": "string",
+                                        "nullable": true,
+                                        "default": null,
+                                        "description": "(optional) branch id within the parent conditional question"
+                                    },
                                     "position": {
                                         "type": "integer",
                                         "format": "int64",
@@ -2387,7 +2423,7 @@
                         }
                     },
                     "400": {
-                        "description": "Invalid extraSettings, will not update.",
+                        "description": "Invalid extraSettings, or a type change to or from a conditional question, will not update",
                         "content": {
                             "application/json": {
                                 "schema": {
@@ -2691,6 +2727,224 @@
                 }
             }
         },
+        "/ocs/v2.php/apps/forms/api/v3/forms/{formId}/subquestions": {
+            "patch": {
+                "operationId": "api-reorder-sub-questions",
+                "summary": "Updates the Order of all Questions in a Branch of a conditional",
+                "description": "This endpoint allows CORS requests",
+                "tags": [
+                    "api"
+                ],
+                "security": [
+                    {
+                        "basic_auth": []
+                    }
+                ],
+                "requestBody": {
+                    "required": true,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "type": "object",
+                                "required": [
+                                    "branchId",
+                                    "parentQuestionId",
+                                    "newOrder"
+                                ],
+                                "properties": {
+                                    "branchId": {
+                                        "type": "string",
+                                        "description": "Id of the branch."
+                                    },
+                                    "parentQuestionId": {
+                                        "type": "integer",
+                                        "format": "int64",
+                                        "description": "Id of the parent trigger question."
+                                    },
+                                    "newOrder": {
+                                        "type": "array",
+                                        "description": "Array of Question-Ids in new order.",
+                                        "items": {
+                                            "type": "integer",
+                                            "format": "int64"
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                "parameters": [
+                    {
+                        "name": "formId",
+                        "in": "path",
+                        "description": "Id of the form to reorder",
+                        "required": true,
+                        "schema": {
+                            "type": "integer",
+                            "format": "int64"
+                        }
+                    },
+                    {
+                        "name": "OCS-APIRequest",
+                        "in": "header",
+                        "description": "Required to be true for the API request to pass",
+                        "required": true,
+                        "schema": {
+                            "type": "boolean",
+                            "default": true
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "the question ids of the given form in the new order",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "required": [
+                                        "ocs"
+                                    ],
+                                    "properties": {
+                                        "ocs": {
+                                            "type": "object",
+                                            "required": [
+                                                "meta",
+                                                "data"
+                                            ],
+                                            "properties": {
+                                                "meta": {
+                                                    "$ref": "#/components/schemas/OCSMeta"
+                                                },
+                                                "data": {
+                                                    "type": "object",
+                                                    "additionalProperties": {
+                                                        "$ref": "#/components/schemas/Order"
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "One question has already been marked as deleted",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "required": [
+                                        "ocs"
+                                    ],
+                                    "properties": {
+                                        "ocs": {
+                                            "type": "object",
+                                            "required": [
+                                                "meta",
+                                                "data"
+                                            ],
+                                            "properties": {
+                                                "meta": {
+                                                    "$ref": "#/components/schemas/OCSMeta"
+                                                },
+                                                "data": {}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "403": {
+                        "description": "User has no permissions to get this form",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "required": [
+                                        "ocs"
+                                    ],
+                                    "properties": {
+                                        "ocs": {
+                                            "type": "object",
+                                            "required": [
+                                                "meta",
+                                                "data"
+                                            ],
+                                            "properties": {
+                                                "meta": {
+                                                    "$ref": "#/components/schemas/OCSMeta"
+                                                },
+                                                "data": {}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "404": {
+                        "description": "Could not find question",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "required": [
+                                        "ocs"
+                                    ],
+                                    "properties": {
+                                        "ocs": {
+                                            "type": "object",
+                                            "required": [
+                                                "meta",
+                                                "data"
+                                            ],
+                                            "properties": {
+                                                "meta": {
+                                                    "$ref": "#/components/schemas/OCSMeta"
+                                                },
+                                                "data": {}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "401": {
+                        "description": "Current user is not logged in",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "required": [
+                                        "ocs"
+                                    ],
+                                    "properties": {
+                                        "ocs": {
+                                            "type": "object",
+                                            "required": [
+                                                "meta",
+                                                "data"
+                                            ],
+                                            "properties": {
+                                                "meta": {
+                                                    "$ref": "#/components/schemas/OCSMeta"
+                                                },
+                                                "data": {}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
         "/ocs/v2.php/apps/forms/api/v3/forms/{formId}/questions/{questionId}/options": {
             "post": {
                 "operationId": "api-new-option",
diff --git a/playwright/e2e/conditional-question.spec.ts b/playwright/e2e/conditional-question.spec.ts
new file mode 100644
index 0000000000..4ea37a722a
--- /dev/null
+++ b/playwright/e2e/conditional-question.spec.ts
@@ -0,0 +1,154 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { APIRequestContext } from '@playwright/test'
+
+import { expect, mergeTests } from '@playwright/test'
+import { test as randomUserTest } from '../support/fixtures/random-user.ts'
+import { test as submitTest } from '../support/fixtures/submit.ts'
+
+const test = mergeTests(randomUserTest, submitTest)
+
+/**
+ * Call the Forms OCS API as the logged in user
+ *
+ * @param request the request context of the page
+ * @param method the HTTP method
+ * @param path the path below `api/v3`
+ * @param data the JSON body
+ */
+async function api(
+	request: APIRequestContext,
+	method: string,
+	path: string,
+	data?: unknown,
+) {
+	const response = await request.fetch(`../ocs/v2.php/apps/forms/api/v3${path}`, {
+		method,
+		data,
+		headers: { 'OCS-APIRequest': 'true', Accept: 'application/json' },
+	})
+	expect(response.ok()).toBeTruthy()
+	return (await response.json()).ocs.data
+}
+
+test.describe('Conditional questions', () => {
+	let formId: number
+	let hash: string
+
+	// A dropdown conditional with one subquestion per answer, followed by a regular question
+	test.beforeEach(async ({ page }) => {
+		const request = page.request
+		;({ id: formId, hash } = await api(request, 'POST', '/forms'))
+		await api(request, 'PATCH', `/forms/${formId}`, {
+			keyValuePairs: { title: 'Conditional form' },
+		})
+
+		const conditional = await api(
+			request,
+			'POST',
+			`/forms/${formId}/questions`,
+			{
+				type: 'conditional',
+				text: 'Do you have dietary restrictions?',
+			},
+		)
+		const [yes, no] = await api(
+			request,
+			'POST',
+			`/forms/${formId}/questions/${conditional.id}/options`,
+			{ optionTexts: ['Yes', 'No'] },
+		)
+		await api(request, 'PATCH', `/forms/${formId}/questions/${conditional.id}`, {
+			keyValuePairs: {
+				extraSettings: {
+					triggerType: 'dropdown',
+					branches: [
+						{ id: 'branch-yes', conditions: [{ optionId: yes.id }] },
+						{ id: 'branch-no', conditions: [{ optionId: no.id }] },
+					],
+				},
+			},
+		})
+		for (const [branchId, text] of [
+			['branch-yes', 'Which ones?'],
+			['branch-no', 'Why not?'],
+		]) {
+			await api(request, 'POST', `/forms/${formId}/questions`, {
+				type: 'short',
+				text,
+				parentQuestionId: conditional.id,
+				branchId,
+			})
+		}
+		await api(request, 'POST', `/forms/${formId}/questions`, {
+			type: 'short',
+			text: 'Favourite word?',
+		})
+
+		await page.goto(`apps/forms/${hash}/submit`)
+	})
+
+	test('Only the subquestions of the chosen answer are shown and stored', async ({
+		page,
+		submitView,
+	}) => {
+		await expect(page.getByText('Which ones?')).toBeHidden()
+
+		await submitView.selectDropdown('Do you have dietary restrictions?', 'Yes')
+		const subQuestion = page.getByRole('listitem', {
+			name: 'Question number 1.1',
+		})
+		await expect(subQuestion.getByRole('textbox')).toHaveAccessibleName(
+			'Which ones?',
+		)
+		await subQuestion.getByRole('textbox').fill('nuts')
+
+		// The regular question keeps its own number and label
+		await expect(
+			page
+				.getByRole('listitem', { name: 'Question number 2' })
+				.getByRole('textbox'),
+		).toHaveAccessibleName('Favourite word?')
+
+		// Changing the answer replaces the subquestions and drops the answer of the other branch
+		await submitView.selectDropdown('Do you have dietary restrictions?', 'No')
+		await expect(page.getByText('Which ones?')).toBeHidden()
+		await page
+			.getByRole('listitem', { name: 'Question number 1.1' })
+			.getByRole('textbox')
+			.fill('no reason')
+
+		await submitView.submit()
+		await expect(submitView.successMessage).toBeVisible()
+
+		const { submissions } = await api(
+			page.request,
+			'GET',
+			`/forms/${formId}/submissions`,
+		)
+		expect(submissions[0].answers.map((answer) => answer.text).sort()).toEqual([
+			'No',
+			'no reason',
+		])
+	})
+
+	test('Element ids stay unique when subquestions are shown', async ({
+		page,
+		submitView,
+	}) => {
+		await submitView.selectDropdown('Do you have dietary restrictions?', 'Yes')
+		await expect(page.getByText('Which ones?')).toBeVisible()
+
+		const duplicateIds = await page.evaluate(() => {
+			const counts: Record<string, number> = {}
+			document.querySelectorAll('main [id]').forEach((element) => {
+				counts[element.id] = (counts[element.id] ?? 0) + 1
+			})
+			return Object.keys(counts).filter((id) => counts[id] > 1)
+		})
+		expect(duplicateIds).toEqual([])
+	})
+})
diff --git a/src/components/Questions/BranchConditionEditor.vue b/src/components/Questions/BranchConditionEditor.vue
new file mode 100644
index 0000000000..0f8daf50f3
--- /dev/null
+++ b/src/components/Questions/BranchConditionEditor.vue
@@ -0,0 +1,139 @@
+<!--
+  - SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+  - SPDX-License-Identifier: AGPL-3.0-or-later
+-->
+
+<template>
+	<div class="branch-condition-editor">
+		<!-- Option-based conditions (radio, dropdown) -->
+		<template v-if="isOptionBasedTrigger">
+			<div class="condition-options">
+				<NcSelect
+					:inputLabel="conditionLabel"
+					:modelValue="selectedOptions"
+					:options="optionsList"
+					:placeholder="t('forms', 'Select an option')"
+					:multiple="false"
+					label="text"
+					@update:modelValue="onSingleOptionSelect" />
+			</div>
+		</template>
+	</div>
+</template>
+
+<script>
+import { t } from '@nextcloud/l10n'
+import NcSelect from '@nextcloud/vue/components/NcSelect'
+
+export default {
+	name: 'BranchConditionEditor',
+
+	components: {
+		NcSelect,
+	},
+
+	props: {
+		/**
+		 * The branch object containing conditions
+		 */
+		branch: {
+			type: Object,
+			required: true,
+		},
+
+		/**
+		 * The trigger question type
+		 */
+		triggerType: {
+			type: String,
+			required: true,
+		},
+
+		/**
+		 * Options for option-based triggers (radio, dropdown, checkbox)
+		 */
+		options: {
+			type: Array,
+			default: () => [],
+		},
+	},
+
+	emits: ['update:branch'],
+
+	computed: {
+		/**
+		 * Check if trigger is option-based (radio, dropdown)
+		 */
+		isOptionBasedTrigger() {
+			return ['multiple_unique', 'dropdown'].includes(this.triggerType)
+		},
+
+		/**
+		 * Label for option-based conditions
+		 */
+		conditionLabel() {
+			return t('forms', 'Show when selected:')
+		},
+
+		/**
+		 * Options list for NcSelect
+		 */
+		optionsList() {
+			return this.options.map((opt) => ({
+				id: opt.id,
+				text: opt.text || t('forms', 'Option {id}', { id: opt.id }),
+			}))
+		},
+
+		/**
+		 * Currently selected options based on branch conditions
+		 */
+		selectedOptions() {
+			if (!this.branch.conditions || this.branch.conditions.length === 0) {
+				return null
+			}
+
+			const selectedIds = this.branch.conditions.map((c) => c.optionId)
+			const selected = this.optionsList.filter((opt) =>
+				selectedIds.includes(opt.id),
+			)
+
+			return selected[0] || null
+		},
+	},
+
+	methods: {
+		/**
+		 * Handle single option selection (radio/dropdown)
+		 *
+		 * @param {object|null} option The selected option or null
+		 */
+		onSingleOptionSelect(option) {
+			const conditions = option ? [{ optionId: option.id }] : []
+			this.emitUpdate({ conditions })
+		},
+
+		/**
+		 * Emit branch update
+		 *
+		 * @param {object} updates The branch properties to update
+		 */
+		emitUpdate(updates) {
+			this.$emit('update:branch', {
+				...this.branch,
+				...updates,
+			})
+		},
+	},
+}
+</script>
+
+<style lang="scss" scoped>
+.branch-condition-editor {
+	padding: 8px 0;
+}
+
+.condition-options {
+	max-width: 400px;
+}
+</style>
diff --git a/src/components/Questions/Question.vue b/src/components/Questions/Question.vue
index 353fad731d..b9a74139f9 100644
--- a/src/components/Questions/Question.vue
+++ b/src/components/Questions/Question.vue
@@ -4,16 +4,22 @@
 -->
 
 <template>
-	<li
+	<!-- The trigger of a conditional question is part of the conditional question's list item -->
+	<component
+		:is="isTriggerQuestion ? 'div' : 'li'"
 		class="question"
 		:class="{
 			'question--editable': !readOnly,
 		}"
-		:aria-label="t('forms', 'Question number {index}', { index })">
+		:aria-label="
+			isTriggerQuestion
+				? undefined
+				: t('forms', 'Question number {index}', { index: number })
+		">
 		<!-- Drag handle -->
 		<!-- TODO: implement arrow key mapping to reorder question -->
 		<div
-			v-if="!readOnly"
+			v-if="!readOnly && !isTriggerQuestion"
 			class="question__drag-handle"
 			:class="{
 				'question__drag-handle--shiftup': shiftDragHandle,
@@ -44,14 +50,14 @@
 		</div>
 
 		<!-- Header -->
-		<div class="question__header">
+		<div v-if="!isTriggerQuestion || !readOnly" class="question__header">
 			<div class="question__header__title">
 				<input
-					v-if="!readOnly"
+					v-if="!isTriggerQuestion && !readOnly"
 					:placeholder="titlePlaceholder"
 					:aria-label="
 						t('forms', 'Title of question number {index}', {
-							index,
+							index: number,
 						})
 					"
 					:value="text"
@@ -63,12 +69,13 @@
 					required
 					@input="onTitleChange" />
 				<h3
-					v-else
+					v-else-if="readOnly"
 					:id="titleId"
 					class="question__header__title__text"
 					dir="auto">
 					{{ computedText }}
 				</h3>
+				<div v-else class="question__header__title__text"></div>
 				<div
 					v-if="!readOnly && !questionValid"
 					:title="warningInvalid"
@@ -76,13 +83,19 @@
 					tabindex="0">
 					<NcIconSvgWrapper :svg="IconAlertCircleOutline" />
 				</div>
+				<!-- A trigger only has the options of its type, the conditional question owns the rest -->
 				<NcActions
-					v-if="!readOnly"
+					v-if="!readOnly && (!isTriggerQuestion || $slots.actions)"
 					:id="actionsId"
+					:aria-label="
+						isTriggerQuestion
+							? t('forms', 'Trigger settings')
+							: undefined
+					"
 					forceMenu
 					placement="bottom-end"
 					class="question__header__title__menu">
-					<template v-if="isRequired" #icon>
+					<template v-if="isRequired && !isTriggerQuestion" #icon>
 						<IconOverlay>
 							<template #overlay>
 								<NcIconSvgWrapper :svg="IconAsterisk" inline />
@@ -91,6 +104,7 @@
 						</IconOverlay>
 					</template>
 					<NcActionCheckbox
+						v-if="!isTriggerQuestion"
 						:modelValue="isRequired"
 						@update:modelValue="onRequiredChange">
 						<!-- TRANSLATORS Making this question necessary to be answered when submitting to a form -->
@@ -98,6 +112,7 @@
 					</NcActionCheckbox>
 					<slot name="actions" />
 					<NcActionInput
+						v-if="!isTriggerQuestion"
 						:label="t('forms', 'Technical name of the question')"
 						:labelOutside="false"
 						:showTrailingButton="false"
@@ -108,13 +123,16 @@
 						</template>
 						{{ t('forms', 'Technical name') }}
 					</NcActionInput>
-					<NcActionButton closeAfterClick @click="onClone">
+					<NcActionButton
+						v-if="!isTriggerQuestion"
+						closeAfterClick
+						@click="onClone">
 						<template #icon>
 							<NcIconSvgWrapper :svg="IconContentCopy" />
 						</template>
 						{{ t('forms', 'Copy question') }}
 					</NcActionButton>
-					<NcActionButton @click="onDelete">
+					<NcActionButton v-if="!isTriggerQuestion" @click="onDelete">
 						<template #icon>
 							<NcIconSvgWrapper :svg="IconDelete" />
 						</template>
@@ -123,7 +141,7 @@
 				</NcActions>
 			</div>
 			<div
-				v-if="hasDescription || !readOnly"
+				v-if="!isTriggerQuestion && (hasDescription || !readOnly)"
 				class="question__header__description">
 				<textarea
 					v-if="!readOnly"
@@ -132,7 +150,7 @@
 					:value="description"
 					:aria-label="
 						t('forms', 'Description of question number {index}', {
-							index,
+							index: number,
 						})
 					"
 					:placeholder="
@@ -159,12 +177,21 @@
 				{{ errorMessage }}
 			</NcNoteCard>
 		</div>
+		<!-- An answered trigger has no header of its own, but its messages are shown -->
+		<template v-else>
+			<NcNoteCard v-if="hasInfo" :id="infoId" type="info">
+				{{ infoMessage }}
+			</NcNoteCard>
+			<NcNoteCard v-if="hasError" :id="errorId" type="error">
+				{{ errorMessage }}
+			</NcNoteCard>
+		</template>
 
 		<!-- Question content -->
 		<slot />
 		<!-- Insert question menu -->
 		<slot name="insert" />
-	</li>
+	</component>
 </template>
 
 <script lang="ts">
@@ -190,6 +217,7 @@ import NcButton from '@nextcloud/vue/components/NcButton'
 import NcIconSvgWrapper from '@nextcloud/vue/components/NcIconSvgWrapper'
 import NcNoteCard from '@nextcloud/vue/components/NcNoteCard'
 import IconOverlay from '../Icons/IconOverlay.vue'
+import { questionIdPrefix, questionNumber } from '../../composables/useQuestion.ts'
 
 export default defineComponent({
 	// eslint-disable-next-line vue/multi-word-component-names
@@ -212,6 +240,11 @@ export default defineComponent({
 			required: true,
 		},
 
+		subIndex: {
+			type: Number,
+			default: null,
+		},
+
 		text: {
 			type: String,
 			required: true,
@@ -282,6 +315,11 @@ export default defineComponent({
 			type: String,
 			default: null,
 		},
+
+		isTriggerQuestion: {
+			type: Boolean,
+			default: false,
+		},
 	},
 
 	emits: [
@@ -327,14 +365,23 @@ export default defineComponent({
 		 * @return true if question valid
 		 */
 		const questionValid = computed(() => !!props.text && props.contentValid)
-		const actionsId = computed(() => 'q' + props.index + '_actions')
-		const titleId = computed(() => 'q' + props.index + '_title')
-		const descriptionId = computed(() => 'q' + props.index + '_desc')
+		const number = computed(() =>
+			questionNumber({ index: props.index, subIndex: props.subIndex }),
+		)
+		// The trigger of a conditional question shares its index, so its own elements need other ids
+		const idPrefix = computed(
+			() =>
+				questionIdPrefix({ index: props.index, subIndex: props.subIndex })
+				+ (props.isTriggerQuestion ? '_trigger' : ''),
+		)
+		const actionsId = computed(() => idPrefix.value + '_actions')
+		const titleId = computed(() => idPrefix.value + '_title')
+		const descriptionId = computed(() => idPrefix.value + '_desc')
 		const hasDescription = computed(() => props.description !== '')
 		const hasError = computed(() => !!props.errorMessage)
 		const hasInfo = computed(() => !!props.infoMessage)
-		const errorId = computed(() => `q${props.index}_error`)
-		const infoId = computed(() => `q${props.index}_info`)
+		const errorId = computed(() => `${idPrefix.value}_error`)
+		const infoId = computed(() => `${idPrefix.value}_info`)
 
 		const resizeDescription = (): void => {
 			// next tick ensures that the textarea is attached to DOM
@@ -425,6 +472,7 @@ export default defineComponent({
 			computedText,
 			computedDescription,
 			questionValid,
+			number,
 			actionsId,
 			titleId,
 			descriptionId,
diff --git a/src/components/Questions/QuestionColor.vue b/src/components/Questions/QuestionColor.vue
index 5241f41a7f..5b96a86c90 100644
--- a/src/components/Questions/QuestionColor.vue
+++ b/src/components/Questions/QuestionColor.vue
@@ -5,6 +5,7 @@
 
 <template>
 	<Question
+		ref="rootElement"
 		v-bind="questionProps"
 		:titlePlaceholder="answerType.titlePlaceholder"
 		:warningInvalid="answerType.warningInvalid"
@@ -48,7 +49,7 @@
 <script lang="ts">
 import IconClose from '@material-symbols/svg-400/outlined/close.svg?raw'
 import { t } from '@nextcloud/l10n'
-import { computed, defineComponent } from 'vue'
+import { computed, defineComponent, ref } from 'vue'
 import NcButton from '@nextcloud/vue/components/NcButton'
 import NcColorPicker from '@nextcloud/vue/components/NcColorPicker'
 import NcIconSvgWrapper from '@nextcloud/vue/components/NcIconSvgWrapper'
@@ -73,7 +74,8 @@ export default defineComponent({
 	emits: [...QUESTION_EMITS, 'update:values'],
 
 	setup(props, { emit }) {
-		const question = useQuestion(props, { emit })
+		const rootElement = ref<{ $el?: HTMLElement } | null>(null)
+		const question = useQuestion(props, { emit, rootElement })
 		const values = computed(() => {
 			return props.values as Array<string | null | undefined>
 		})
@@ -107,6 +109,7 @@ export default defineComponent({
 
 		return {
 			...question,
+			rootElement,
 			IconClose,
 			t,
 			colorPickerPlaceholder,
diff --git a/src/components/Questions/QuestionConditional.vue b/src/components/Questions/QuestionConditional.vue
new file mode 100644
index 0000000000..aa7c9a2c26
--- /dev/null
+++ b/src/components/Questions/QuestionConditional.vue
@@ -0,0 +1,1104 @@
+<!--
+  - SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+  - SPDX-License-Identifier: AGPL-3.0-or-later
+-->
+
+<template>
+	<Question
+		ref="rootElement"
+		v-bind="questionProps"
+		:titlePlaceholder="answerType.titlePlaceholder"
+		:warningInvalid="answerType.warningInvalid"
+		:contentValid="contentValid"
+		:shiftDragHandle="false"
+		v-on="commonListeners">
+		<div class="question-conditional">
+			<!-- Trigger Type Selection (Edit Mode) -->
+			<div
+				v-if="!readOnly && (!triggerType || isChangingTriggerType)"
+				ref="triggerTypeSelector"
+				class="trigger-type-selector">
+				<p class="trigger-type-selector__label">
+					{{ t('forms', 'Select the trigger question type:') }}
+				</p>
+				<p v-if="isChangingTriggerType" class="trigger-type-selector__hint">
+					{{
+						t(
+							'forms',
+							'The conditions of all branches are reset, the subquestions are kept.',
+						)
+					}}
+				</p>
+				<div class="trigger-type-selector__options">
+					<div
+						v-for="group in triggerTypeGroups"
+						:key="group.label"
+						class="trigger-type-selector__group">
+						<p class="trigger-type-selector__group-label">
+							{{ group.label }}
+						</p>
+						<div class="trigger-type-selector__group-options">
+							<NcButton
+								v-for="tt in group.types"
+								:key="tt.type"
+								variant="secondary"
+								@click="setTriggerType(tt.type)">
+								<template #icon>
+									<NcIconSvgWrapper :svg="tt.icon" />
+								</template>
+								{{ tt.label }}
+							</NcButton>
+						</div>
+					</div>
+				</div>
+				<NcButton
+					v-if="isChangingTriggerType"
+					class="trigger-type-selector__cancel"
+					variant="tertiary"
+					@click="keepTriggerType">
+					{{ t('forms', 'Keep the current trigger type') }}
+				</NcButton>
+			</div>
+
+			<!-- Trigger Question -->
+			<div v-else-if="triggerType" class="trigger-question">
+				<div v-if="!readOnly" class="trigger-question__header">
+					<NcIconSvgWrapper
+						:svg="currentTriggerIcon"
+						class="trigger-question__icon" />
+					<span class="trigger-question__type-label">
+						{{
+							t('forms', 'Trigger type: {type}', {
+								type: currentTriggerLabel,
+							})
+						}}
+					</span>
+					<NcButton
+						ref="changeTriggerTypeButton"
+						variant="tertiary"
+						:aria-label="t('forms', 'Change trigger type')"
+						@click="clearTriggerType">
+						<template #icon>
+							<NcIconSvgWrapper :svg="IconPencil" />
+						</template>
+					</NcButton>
+				</div>
+
+				<!-- Instructions for option-based triggers -->
+				<p
+					v-if="!readOnly && isOptionBasedTrigger"
+					class="trigger-question__instructions">
+					{{
+						t(
+							'forms',
+							'Add the answer options below. These will be used as trigger conditions.',
+						)
+					}}
+				</p>
+
+				<!-- Render the appropriate trigger question component -->
+				<component
+					:is="triggerComponent"
+					v-if="triggerComponent"
+					:id="id"
+					ref="triggerQuestion"
+					:formId="formId"
+					:text="text"
+					:description="description"
+					:isRequired="isRequired"
+					:index="index"
+					:options="options"
+					:extraSettings="triggerExtraSettings"
+					:maxStringLengths="maxStringLengths"
+					:answerType="triggerAnswerTypeConfig"
+					:readOnly="readOnly"
+					:isTriggerQuestion="true"
+					:values="triggerValues"
+					@update:values="onTriggerValueChange"
+					@keydown="$emit('keydown', $event)"
+					@update:options="onOptionsChange"
+					@update:extraSettings="updateExtraSettings" />
+
+				<!-- Branch Management (Edit Mode) -->
+				<div v-if="!readOnly" class="branches-editor">
+					<h3 class="branches-editor__title">
+						{{
+							text
+								? t(
+										'forms',
+										'Branches of "{question}"',
+										{ question: text },
+										{ escape: false, sanitize: false },
+									)
+								: t('forms', 'Conditional Branches')
+						}}
+					</h3>
+					<p class="branches-editor__description">
+						{{
+							t(
+								'forms',
+								'Define which subquestions appear based on the answer above.',
+							)
+						}}
+					</p>
+
+					<!-- List of branches -->
+					<TransitionGroup tag="div" name="branch-list">
+						<div
+							v-for="(branch, branchIndex) in branches"
+							:key="branch.id"
+							class="branch"
+							role="group"
+							:aria-labelledby="`${branchIdPrefix}${branch.id}`">
+							<div class="branch__header">
+								<span
+									:id="`${branchIdPrefix}${branch.id}`"
+									class="branch__label">
+									{{ getBranchLabel(branch, branchIndex) }}
+								</span>
+								<NcButton
+									variant="tertiary"
+									:aria-label="
+										t(
+											'forms',
+											'Delete branch {label}',
+											{
+												label: getBranchLabel(
+													branch,
+													branchIndex,
+												),
+											},
+											{ escape: false, sanitize: false },
+										)
+									"
+									@click="deleteBranch(branch.id)">
+									<template #icon>
+										<NcIconSvgWrapper
+											:svg="IconDelete"></NcIconSvgWrapper>
+									</template>
+								</NcButton>
+							</div>
+
+							<!-- Branch Conditions -->
+							<div class="branch__conditions">
+								<BranchConditionEditor
+									:branch="branch"
+									:triggerType="triggerType"
+									:options="options"
+									@update:branch="
+										onBranchUpdate(branchIndex, $event)
+									" />
+							</div>
+
+							<!-- Subquestions for this branch -->
+							<div class="branch__subquestions">
+								<QuestionList
+									ref="subQuestionLists"
+									:modelValue="branch.subQuestions"
+									:getComponent="getSubQuestionComponent"
+									:getAnswerType="getSubQuestionAnswerType"
+									:maxStringLengths="maxStringLengths"
+									:baseIndex="index"
+									isSubQuestionList
+									:subIndexOffset="subIndexOffsets[branchIndex]"
+									:animation="200"
+									:formId="formId"
+									:showInsert="true"
+									:answerTypesFilter="subQuestionAnswerTypesFilter"
+									:hasSubtypes="hasSubtypes"
+									:isLoadingQuestions="isLoadingQuestions"
+									@updateProperty="
+										(idx, prop, val) =>
+											updateSubQuestion(
+												branch.id,
+												branches[branchIndex].subQuestions[
+													idx
+												].id,
+												prop,
+												val,
+											)
+									"
+									@clone="
+										(question) =>
+											cloneSubQuestion(branch.id, question.id)
+									"
+									@delete="
+										(question) =>
+											deleteSubQuestion(branch.id, question.id)
+									"
+									@moveDown="(idx) => onMoveDown(idx, branchIndex)"
+									@moveUp="(idx) => onMoveUp(idx, branchIndex)"
+									@update:modelValue="
+										(questions) =>
+											onQuestionOrderChange(
+												branchIndex,
+												questions,
+											)
+									"
+									@addQuestion="
+										(type, subtype, position) =>
+											addSubQuestion(branch.id, type, position)
+									" />
+
+								<!-- Add subquestion button -->
+								<NcActions
+									:aria-label="
+										t(
+											'forms',
+											'Add subquestion to branch {label}',
+											{
+												label: getBranchLabel(
+													branch,
+													branchIndex,
+												),
+											},
+											{ escape: false, sanitize: false },
+										)
+									">
+									<template #icon>
+										<NcIconSvgWrapper :svg="IconPlus" />
+									</template>
+									<NcActionButton
+										v-for="sqType in subQuestionTypesList"
+										:key="sqType.type"
+										:closeAfterClick="true"
+										@click="
+											addSubQuestion(branch.id, sqType.type)
+										">
+										<template #icon>
+											<NcIconSvgWrapper :svg="sqType.icon" />
+										</template>
+										{{ sqType.label }}
+									</NcActionButton>
+								</NcActions>
+							</div>
+						</div>
+					</TransitionGroup>
+					<!-- Add new branch button -->
+					<NcButton
+						ref="addBranchButton"
+						variant="secondary"
+						@click="addBranch">
+						<template #icon>
+							<NcIconSvgWrapper :svg="IconPlus" />
+						</template>
+						{{ t('forms', 'Add branch') }}
+					</NcButton>
+				</div>
+
+				<!-- Submit Mode: Show only the active branch's subquestions -->
+				<div v-else class="active-subquestions">
+					<!-- Announce subquestions that appear or disappear on a trigger change -->
+					<div class="hidden-visually" aria-live="polite">
+						{{ subQuestionsStatus }}
+					</div>
+					<TransitionGroup tag="ul" name="branch-list">
+						<component
+							:is="getSubQuestionComponent(subQuestion)"
+							v-for="(subQuestion, subIndex) in activeSubQuestions"
+							:key="subQuestion.id"
+							ref="subQuestions"
+							v-bind="subQuestion"
+							:formId="formId"
+							:index="index"
+							:subIndex="subIndex + 1"
+							:maxStringLengths="maxStringLengths"
+							:answerType="getSubQuestionAnswerType(subQuestion)"
+							:readOnly="true"
+							:values="getSubQuestionValues(subQuestion.id)"
+							@update:values="
+								onSubQuestionValueChange(subQuestion.id, $event)
+							"
+							@keydown="$emit('keydown', $event)" />
+					</TransitionGroup>
+				</div>
+			</div>
+		</div>
+		<slot name="insert" />
+	</Question>
+</template>
+
+<script>
+// Icons
+import IconPlus from '@material-symbols/svg-400/outlined/add.svg?raw'
+import IconDelete from '@material-symbols/svg-400/outlined/delete.svg?raw'
+import IconPencil from '@material-symbols/svg-400/outlined/edit.svg?raw'
+import axios from '@nextcloud/axios'
+import { showError } from '@nextcloud/dialogs'
+import { emit } from '@nextcloud/event-bus'
+import { n, t } from '@nextcloud/l10n'
+import { generateOcsUrl } from '@nextcloud/router'
+import { defineComponent, ref, toRaw } from 'vue'
+import NcActionButton from '@nextcloud/vue/components/NcActionButton'
+import NcActions from '@nextcloud/vue/components/NcActions'
+import NcButton from '@nextcloud/vue/components/NcButton'
+import NcIconSvgWrapper from '@nextcloud/vue/components/NcIconSvgWrapper'
+import BranchConditionEditor from './BranchConditionEditor.vue'
+import Question from './Question.vue'
+import QuestionList from './QuestionList.vue'
+import {
+	QUESTION_EMITS,
+	QUESTION_PROPS,
+	useQuestion,
+} from '../../composables/useQuestion.ts'
+// AnswerTypes.ts imports this component as well, so it is only read when rendering, not on import
+import answerTypes from '../../models/AnswerTypes.ts'
+import logger from '../../utils/Logger.ts'
+import OcsResponse2Data from '../../utils/OcsResponse2Data.ts'
+
+// Types of subquestions, conditional questions can not be nested
+const SUBQUESTION_TYPES = [
+	'short',
+	'long',
+	'multiple',
+	'multiple_unique',
+	'dropdown',
+	'date',
+	'time',
+	'linearscale',
+	'color',
+	'file',
+	'ranking',
+]
+
+// Values of all unanswered subquestions, the same array does not render them again on every answer
+const NO_VALUES = Object.freeze([])
+
+export default defineComponent({
+	name: 'QuestionConditional',
+
+	components: {
+		BranchConditionEditor,
+		NcActionButton,
+		NcActions,
+		NcButton,
+		NcIconSvgWrapper,
+		Question,
+		QuestionList,
+	},
+
+	inheritAttrs: false,
+	props: QUESTION_PROPS,
+	emits: [...QUESTION_EMITS, 'update:options'],
+
+	setup(props, { emit }) {
+		const rootElement = ref(null)
+		const question = useQuestion(props, { emit, rootElement })
+		return {
+			...question,
+			rootElement,
+			t,
+			IconPlus,
+			IconDelete,
+			IconPencil,
+		}
+	},
+
+	data() {
+		return {
+			isLoadingQuestions: false,
+			isChangingTriggerType: false,
+			subQuestionsStatus: '',
+			triggerValues: [],
+			subQuestionValues: {},
+		}
+	},
+
+	computed: {
+		triggerTypeGroups() {
+			const groups = [
+				{
+					label: t('forms', 'Choice'),
+					types: ['multiple_unique', 'dropdown'],
+				},
+			]
+
+			return groups.map((group) => ({
+				...group,
+				types: group.types.map((type) =>
+					this.subQuestionTypesList.find((item) => item.type === type),
+				),
+			}))
+		},
+
+		/**
+		 * Subquestion types (excludes conditional to prevent recursion)
+		 */
+		subQuestionTypesList() {
+			return SUBQUESTION_TYPES.map((type) => ({
+				type,
+				icon: answerTypes[type].icon,
+				label: answerTypes[type].label,
+			}))
+		},
+
+		triggerType() {
+			return this.extraSettings?.triggerType || null
+		},
+
+		currentTriggerIcon() {
+			return answerTypes[this.triggerType]?.icon ?? ''
+		},
+
+		currentTriggerLabel() {
+			return answerTypes[this.triggerType]?.label ?? ''
+		},
+
+		/**
+		 * Check if trigger type uses predefined options (radio, dropdown)
+		 */
+		isOptionBasedTrigger() {
+			return ['multiple_unique', 'dropdown'].includes(this.triggerType)
+		},
+
+		triggerComponent() {
+			return answerTypes[this.triggerType]?.component ?? null
+		},
+
+		triggerAnswerTypeConfig() {
+			return answerTypes[this.triggerType] ?? null
+		},
+
+		triggerExtraSettings() {
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			const { triggerType, branches, ...rest } = this.extraSettings || {}
+			return rest
+		},
+
+		branches() {
+			return this.extraSettings?.branches || []
+		},
+
+		getSubQuestionComponent() {
+			return (question) => answerTypes[question.type]?.component
+		},
+
+		getSubQuestionAnswerType() {
+			return (question) => answerTypes[question.type]
+		},
+
+		/**
+		 * Build answerTypes filter for subquestion insert menu
+		 * Filters out 'conditional' to prevent recursion
+		 */
+		subQuestionAnswerTypesFilter() {
+			const filter = {}
+			for (const sqType of this.subQuestionTypesList) {
+				filter[sqType.type] = {
+					icon: sqType.icon,
+					label: sqType.label,
+				}
+			}
+			return filter
+		},
+
+		/**
+		 * Check if an answer type has subtypes
+		 */
+		hasSubtypes() {
+			return (answer) =>
+				answer && answer.subtypes && Object.keys(answer.subtypes).length > 0
+		},
+
+		activeBranches() {
+			// An unanswered trigger activates no branch
+			if (!this.triggerValues || this.triggerValues.length === 0) {
+				return null
+			}
+			return this.branches.filter((branch) =>
+				this.evaluateBranchCondition(branch),
+			)
+		},
+
+		activeSubQuestions() {
+			// Like other questions, subquestions without a title or without options are not shown
+			const isShown = (question) =>
+				!!question.text?.trim()
+				&& (answerTypes[question.type]?.validate?.(question) ?? true)
+			return (this.activeBranches ?? [])
+				.flatMap((branch) => branch.subQuestions ?? [])
+				.filter(isShown)
+		},
+
+		/**
+		 * Subquestions are numbered across the branches, so each branch starts after the previous ones
+		 */
+		subIndexOffsets() {
+			let offset = 0
+			return this.branches.map((branch) => {
+				const start = offset
+				offset += branch.subQuestions?.length ?? 0
+				return start
+			})
+		},
+
+		branchIdPrefix() {
+			return `conditional-${this.id}-branch-`
+		},
+
+		contentValid() {
+			return !!this.triggerType && this.branches.length > 0
+		},
+	},
+
+	watch: {
+		activeSubQuestions(newQuestions, oldQuestions) {
+			const ids = (questions) =>
+				questions.map((question) => question.id).join()
+			if (ids(newQuestions) === ids(oldQuestions)) {
+				return
+			}
+
+			const status =
+				newQuestions.length > 0
+					? n(
+							'forms',
+							'%n follow-up question shown',
+							'%n follow-up questions shown',
+							newQuestions.length,
+						)
+					: t('forms', 'Follow-up questions removed')
+			// Screen readers only announce a changed text, other questions with the same count need a new one
+			this.subQuestionsStatus = ''
+			this.$nextTick(() => {
+				this.subQuestionsStatus = status
+			})
+		},
+
+		values: {
+			immediate: true,
+			handler(newValues) {
+				// The values emitted last leave out the answers of hidden branches, keep them
+				if (newValues && toRaw(newValues) === this.emittedValues) {
+					return
+				}
+
+				this.triggerValues = newValues?.trigger ?? []
+				this.subQuestionValues = { ...(newValues?.subQuestions ?? {}) }
+
+				// Restored answers can belong to subquestions that are not shown (anymore)
+				const shownIds = new Set(
+					this.activeSubQuestions.map((question) => String(question.id)),
+				)
+				if (
+					Object.keys(this.subQuestionValues).some(
+						(id) => !shownIds.has(id),
+					)
+				) {
+					this.emitValues()
+				}
+			},
+		},
+	},
+
+	methods: {
+		setTriggerType(type) {
+			const previousType = this.triggerType
+			this.isChangingTriggerType = false
+			// The type selection is replaced by the trigger
+			this.focusChangeTriggerType()
+			if (type === previousType) {
+				return
+			}
+
+			// Settings of the previous trigger type would be invalid for the new one,
+			// undefined keys are left out when saving
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			const { triggerType, branches, ...previousSettings } =
+				this.extraSettings || {}
+			const clearedSettings = Object.fromEntries(
+				Object.keys(previousSettings).map((key) => [key, undefined]),
+			)
+
+			this.updateExtraSettings({
+				...clearedSettings,
+				triggerType: type,
+				// Conditions depend on the trigger type, the subquestions are kept
+				branches: previousType
+					? this.branches.map((branch) => ({ ...branch, conditions: [] }))
+					: this.branches,
+			})
+		},
+
+		clearTriggerType() {
+			this.isChangingTriggerType = true
+			this.$nextTick(() => {
+				this.$refs.triggerTypeSelector?.querySelector('button')?.focus()
+			})
+		},
+
+		keepTriggerType() {
+			this.isChangingTriggerType = false
+			this.focusChangeTriggerType()
+		},
+
+		focusChangeTriggerType() {
+			this.$nextTick(() => {
+				this.$refs.changeTriggerTypeButton?.$el.focus()
+			})
+		},
+
+		/**
+		 * Change the extra settings right away and save them debounced
+		 *
+		 * Saving stores the settings as they are by then, so a change made meanwhile is not lost.
+		 *
+		 * @param {object} settings The changed extra settings
+		 */
+		updateExtraSettings(settings) {
+			this.$emit('update:extraSettings', {
+				...this.extraSettings,
+				...settings,
+			})
+			this.onExtraSettingsChange({})
+		},
+
+		onTriggerValueChange(values) {
+			this.triggerValues = values
+			this.emitValues()
+		},
+
+		onOptionsChange(options) {
+			this.$emit('update:options', options)
+		},
+
+		addBranch() {
+			const newBranch = {
+				id: `branch-${Date.now()}`,
+				conditions: [],
+				subQuestions: [],
+			}
+			const newBranches = [...this.branches, newBranch]
+			this.updateExtraSettings({ branches: newBranches })
+		},
+
+		deleteBranch(branchId) {
+			const newBranches = this.branches.filter((b) => b.id !== branchId)
+			this.updateExtraSettings({ branches: newBranches })
+			// The focused delete button is gone with its branch
+			this.$nextTick(() => {
+				this.$refs.addBranchButton?.$el.focus()
+			})
+		},
+
+		onBranchUpdate(index, branch) {
+			const newBranches = [...this.branches]
+			newBranches[index] = branch
+			this.updateExtraSettings({ branches: newBranches })
+		},
+
+		getBranchLabel(branch, index) {
+			if (!branch.conditions || branch.conditions.length === 0) {
+				return t('forms', 'Branch {number} (no conditions)', {
+					number: index + 1,
+				})
+			}
+
+			if (this.isOptionBasedTrigger) {
+				const optionIds = branch.conditions.map((c) => c.optionId)
+				const optionTexts = optionIds
+					.map((id) => this.options.find((o) => o.id === id)?.text)
+					.filter(Boolean)
+				if (optionTexts.length > 0) {
+					return optionTexts.join(' + ')
+				}
+			}
+
+			return t('forms', 'Branch {number}', { number: index + 1 })
+		},
+
+		async addSubQuestion(branchId, type, position = null) {
+			if (!this.branches.some((b) => b.id === branchId)) return
+
+			const body = {
+				type,
+				text: '',
+				parentQuestionId: this.id,
+				branchId,
+			}
+			if (position !== null) {
+				// position: current question position + 2 (0-based index: +1, next position: +1)
+				body.position = position + 2
+			}
+
+			try {
+				const response = await axios.post(
+					generateOcsUrl('apps/forms/api/v3/forms/{id}/questions', {
+						id: this.formId,
+					}),
+					body,
+				)
+				const newQuestion = OcsResponse2Data(response)
+
+				// Use the branch as it is now, it may have changed during the request
+				const branchIndex = this.branches.findIndex((b) => b.id === branchId)
+				if (branchIndex === -1) return
+				const branch = this.branches[branchIndex]
+				const newSubQuestions = [...(branch.subQuestions || [])]
+				if (position !== null) {
+					newSubQuestions.splice(position + 1, 0, newQuestion)
+				} else {
+					newSubQuestions.push(newQuestion)
+				}
+				const newBranches = [...this.branches]
+				newBranches[branchIndex] = {
+					...branch,
+					subQuestions: newSubQuestions,
+				}
+				this.$emit('update:extraSettings', {
+					...this.extraSettings,
+					branches: newBranches,
+				})
+				this.$nextTick(() => {
+					this.$refs.subQuestionLists?.forEach((list) =>
+						list.focusQuestion(newQuestion.id),
+					)
+				})
+			} catch (error) {
+				logger.error('Error adding subquestion', { error })
+				showError(t('forms', 'Error adding subquestion'))
+			}
+		},
+
+		onMoveUp(index, branchIndex) {
+			const subQuestions = [...this.branches[branchIndex].subQuestions]
+
+			if (index > 0) {
+				;[subQuestions[index - 1], subQuestions[index]] = [
+					subQuestions[index],
+					subQuestions[index - 1],
+				]
+			}
+			this.onQuestionOrderChange(branchIndex, subQuestions)
+		},
+
+		onMoveDown(index, branchIndex) {
+			// only if not the last one
+			if (index < this.branches[branchIndex].subQuestions.length - 1) {
+				this.onMoveUp(index + 1, branchIndex)
+			}
+		},
+
+		async onQuestionOrderChange(branchIndex, subQuestions) {
+			this.isLoadingQuestions = true
+			const branch = this.branches[branchIndex]
+			const newBranches = [...this.branches]
+			newBranches[branchIndex] = { ...branch, subQuestions }
+			this.$emit('update:extraSettings', {
+				...this.extraSettings,
+				branches: newBranches,
+			})
+			const newOrder = subQuestions.map((question) => question.id)
+			try {
+				await axios.patch(
+					generateOcsUrl('apps/forms/api/v3/forms/{id}/subquestions', {
+						id: this.formId,
+					}),
+					{
+						newOrder,
+						branchId: branch.id,
+						parentQuestionId: this.id,
+					},
+				)
+				emit('forms:last-updated:set', this.formId)
+			} catch (error) {
+				logger.error('Error while saving form', { error })
+				showError(t('forms', 'Error while saving form'))
+			} finally {
+				this.isLoadingQuestions = false
+			}
+		},
+
+		async cloneSubQuestion(branchId, questionId) {
+			if (!this.branches.some((b) => b.id === branchId)) return
+
+			try {
+				const response = await axios.post(
+					generateOcsUrl(
+						'apps/forms/api/v3/forms/{id}/questions?fromId={questionId}',
+						{
+							id: this.formId,
+							questionId,
+						},
+					),
+				)
+				const newQuestion = OcsResponse2Data(response)
+
+				// Use the branch as it is now, it may have changed during the request
+				const branchIndex = this.branches.findIndex((b) => b.id === branchId)
+				if (branchIndex === -1) return
+				const branch = this.branches[branchIndex]
+				const newBranches = [...this.branches]
+				newBranches[branchIndex] = {
+					...branch,
+					subQuestions: [...(branch.subQuestions || []), newQuestion],
+				}
+				this.$emit('update:extraSettings', {
+					...this.extraSettings,
+					branches: newBranches,
+				})
+			} catch (error) {
+				logger.error('Error adding subquestion', { error })
+				showError(t('forms', 'Error adding subquestion'))
+			}
+		},
+
+		async deleteSubQuestion(branchId, questionId) {
+			try {
+				await axios.delete(
+					generateOcsUrl(
+						'apps/forms/api/v3/forms/{id}/questions/{questionId}',
+						{
+							id: this.formId,
+							questionId,
+						},
+					),
+				)
+
+				const branchIndex = this.branches.findIndex((b) => b.id === branchId)
+				if (branchIndex === -1) return
+				const branch = this.branches[branchIndex]
+				const newBranches = [...this.branches]
+				newBranches[branchIndex] = {
+					...branch,
+					subQuestions: branch.subQuestions.filter(
+						(q) => q.id !== questionId,
+					),
+				}
+				this.$emit('update:extraSettings', {
+					...this.extraSettings,
+					branches: newBranches,
+				})
+			} catch (error) {
+				logger.error('Error deleting subquestion', { error })
+				showError(t('forms', 'Error deleting subquestion'))
+			}
+		},
+
+		updateSubQuestion(branchId, questionId, property, value) {
+			const branchIndex = this.branches.findIndex((b) => b.id === branchId)
+			const branch = this.branches[branchIndex]
+
+			const newBranches = [...this.branches]
+			newBranches[branchIndex] = {
+				...branch,
+				subQuestions: branch.subQuestions.map((q) =>
+					q.id === questionId ? { ...q, [property]: value } : q,
+				),
+			}
+			this.$emit('update:extraSettings', {
+				...this.extraSettings,
+				branches: newBranches,
+			})
+		},
+
+		getSubQuestionValues(questionId) {
+			return this.subQuestionValues[questionId] ?? NO_VALUES
+		},
+
+		onSubQuestionValueChange(questionId, values) {
+			this.subQuestionValues = {
+				...this.subQuestionValues,
+				[questionId]: values,
+			}
+			this.emitValues()
+		},
+
+		emitValues() {
+			// Only send the answers of the subquestions that are shown, answers of other
+			// branches are kept here in case the trigger is changed back
+			const shownIds = new Set(
+				this.activeSubQuestions.map((question) => String(question.id)),
+			)
+			this.emittedValues = {
+				trigger: this.triggerValues,
+				subQuestions: Object.fromEntries(
+					Object.entries(this.subQuestionValues).filter(([id]) =>
+						shownIds.has(id),
+					),
+				),
+			}
+			this.$emit('update:values', this.emittedValues)
+		},
+
+		evaluateBranchCondition(branch) {
+			if (!branch.conditions || branch.conditions.length === 0) {
+				return false
+			}
+
+			// Convert triggerValues to strings for consistent comparison
+			const triggerValuesAsStrings = this.triggerValues.map((v) => String(v))
+
+			if (['multiple_unique', 'dropdown'].includes(this.triggerType)) {
+				return branch.conditions.some((c) =>
+					triggerValuesAsStrings.includes(String(c.optionId)),
+				)
+			}
+
+			return false
+		},
+
+		async validate() {
+			if (this.$refs.triggerQuestion?.validate) {
+				const triggerValid = await this.$refs.triggerQuestion.validate()
+				if (!triggerValid) return false
+			}
+
+			if (this.$refs.subQuestions) {
+				for (const subQuestion of this.$refs.subQuestions) {
+					if (subQuestion.validate) {
+						const valid = await subQuestion.validate()
+						if (!valid) return false
+					}
+				}
+			}
+
+			return true
+		},
+	},
+})
+</script>
+
+<style lang="scss" scoped>
+.question-conditional {
+	display: flex;
+	flex-direction: column;
+	gap: 16px;
+}
+
+.trigger-type-selector {
+	padding: 16px;
+	background-color: var(--color-background-dark);
+	border-radius: var(--border-radius-large);
+
+	&__label {
+		margin-bottom: 12px;
+		font-weight: bold;
+	}
+
+	&__options {
+		display: flex;
+		flex-direction: column;
+		gap: 12px;
+	}
+
+	&__group-label {
+		margin-bottom: 4px;
+		color: var(--color-text-maxcontrast);
+		font-size: 0.9em;
+	}
+
+	&__group-options {
+		display: flex;
+		flex-wrap: wrap;
+		gap: 8px;
+	}
+}
+
+.trigger-question {
+	&__header {
+		display: flex;
+		align-items: center;
+		gap: 8px;
+		margin-bottom: 12px;
+		padding: 8px;
+		background-color: var(--color-primary-element-light);
+		border-radius: var(--border-radius);
+	}
+
+	&__icon {
+		color: var(--color-primary-element);
+	}
+
+	&__type-label {
+		font-weight: 500;
+		flex: 1;
+	}
+
+	&__instructions {
+		margin: 0 0 12px 0;
+		padding: 8px 12px;
+		background-color: var(--color-background-hover);
+		border-radius: var(--border-radius);
+		color: var(--color-text-maxcontrast);
+		font-size: 0.9em;
+	}
+}
+
+.branches-editor {
+	margin-top: 24px;
+	padding: 16px;
+	background-color: var(--color-background-dark);
+	border-radius: var(--border-radius-large);
+
+	&__title {
+		margin: 0 0 8px 0;
+		font-size: 1.1em;
+	}
+
+	&__description {
+		margin-bottom: 16px;
+		color: var(--color-text-maxcontrast);
+	}
+}
+
+.branch {
+	margin-bottom: 16px;
+	padding: 12px;
+	background-color: var(--color-main-background);
+	border: 1px solid var(--color-border);
+	border-radius: var(--border-radius);
+
+	&__header {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		margin-bottom: 12px;
+	}
+
+	&__label {
+		font-weight: 500;
+	}
+
+	&__conditions {
+		margin-bottom: 12px;
+	}
+
+	&__subquestions {
+		padding-left: 16px;
+		border-left: 3px solid var(--color-primary-element-light);
+
+		// Phones have little width to spare, the border still shows the nesting
+		@media (max-width: 768px) {
+			padding-left: 8px;
+		}
+	}
+}
+
+.active-subquestions {
+	margin-top: 16px;
+	padding-left: 16px;
+	border-left: 3px solid var(--color-primary-element);
+
+	// Phones have little width to spare, the border still shows the nesting
+	@media (max-width: 768px) {
+		padding-left: 8px;
+	}
+}
+
+.branch-list-move,
+.branch-list-enter-active,
+.branch-list-leave-active {
+	transition: all var(--animation-slow) ease;
+}
+
+.branch-list-enter-from,
+.branch-list-leave-to {
+	opacity: 0;
+	transform: translateX(var(--clickable-area-large));
+}
+
+.branch-list-leave-active {
+	position: absolute;
+}
+</style>
diff --git a/src/components/Questions/QuestionDate.vue b/src/components/Questions/QuestionDate.vue
index 0d87070114..2c66716310 100644
--- a/src/components/Questions/QuestionDate.vue
+++ b/src/components/Questions/QuestionDate.vue
@@ -5,6 +5,7 @@
 
 <template>
 	<Question
+		ref="rootElement"
 		v-bind="questionProps"
 		:titlePlaceholder="answerType.titlePlaceholder"
 		:warningInvalid="answerType.warningInvalid"
@@ -112,7 +113,7 @@
 <script lang="ts">
 import { t } from '@nextcloud/l10n'
 import moment from '@nextcloud/moment'
-import { computed, defineComponent } from 'vue'
+import { computed, defineComponent, ref } from 'vue'
 import NcActionCheckbox from '@nextcloud/vue/components/NcActionCheckbox'
 import NcActionInput from '@nextcloud/vue/components/NcActionInput'
 import NcDateTimePicker from '@nextcloud/vue/components/NcDateTimePicker'
@@ -155,7 +156,8 @@ export default defineComponent({
 	emits: [...QUESTION_EMITS, 'update:values'],
 
 	setup(props, { emit }) {
-		const question = useQuestion(props, { emit })
+		const rootElement = ref<{ $el?: HTMLElement } | null>(null)
+		const question = useQuestion(props, { emit, rootElement })
 		const values = computed(() => {
 			return props.values as Array<string | undefined>
 		})
@@ -460,6 +462,7 @@ export default defineComponent({
 
 		return {
 			...question,
+			rootElement,
 			extraSettingsFormatter: {
 				stringify: stringifyDate,
 				parse: parseTimestampToDate,
diff --git a/src/components/Questions/QuestionDropdown.vue b/src/components/Questions/QuestionDropdown.vue
index a22aea3669..1b3eee327e 100644
--- a/src/components/Questions/QuestionDropdown.vue
+++ b/src/components/Questions/QuestionDropdown.vue
@@ -5,6 +5,7 @@
 
 <template>
 	<Question
+		ref="rootElement"
 		v-bind="questionProps"
 		:titlePlaceholder="answerType.titlePlaceholder"
 		:warningInvalid="answerType.warningInvalid"
@@ -144,7 +145,8 @@ export default defineComponent({
 	emits: [...QUESTION_EMITS, ...QUESTION_MULTIPLE_EMITS, 'update:values'],
 
 	setup(props, { emit }) {
-		const question = useQuestion(props, { emit })
+		const rootElement = ref<{ $el?: HTMLElement } | null>(null)
+		const question = useQuestion(props, { emit, rootElement })
 		const values = computed<Array<number | string>>(() => {
 			return Array.isArray(props.values) ? props.values : []
 		})
@@ -246,6 +248,7 @@ export default defineComponent({
 
 		return {
 			...question,
+			rootElement,
 			...questionMultiple,
 			input,
 			choices,
diff --git a/src/components/Questions/QuestionFile.vue b/src/components/Questions/QuestionFile.vue
index 8d2245da04..2f39ef537b 100644
--- a/src/components/Questions/QuestionFile.vue
+++ b/src/components/Questions/QuestionFile.vue
@@ -5,6 +5,7 @@
 
 <template>
 	<Question
+		ref="rootElement"
 		v-bind="questionProps"
 		:titlePlaceholder="answerType.titlePlaceholder"
 		:warningInvalid="answerType.warningInvalid"
@@ -237,7 +238,8 @@ export default defineComponent({
 	emits: [...QUESTION_EMITS, 'update:values'],
 
 	setup(props, { emit }) {
-		const question = useQuestion(props, { emit })
+		const rootElement = ref<{ $el?: HTMLElement } | null>(null)
+		const question = useQuestion(props, { emit, rootElement })
 		const values = computed<UploadedFileValue[]>(() => {
 			return props.values as UploadedFileValue[]
 		})
@@ -512,6 +514,7 @@ export default defineComponent({
 
 		return {
 			...question,
+			rootElement,
 			values,
 			IconChevronLeft,
 			IconDelete,
diff --git a/src/components/Questions/QuestionGrid.vue b/src/components/Questions/QuestionGrid.vue
index c85810ec4b..5d5db5db64 100644
--- a/src/components/Questions/QuestionGrid.vue
+++ b/src/components/Questions/QuestionGrid.vue
@@ -5,6 +5,7 @@
 
 <template>
 	<Question
+		ref="rootElement"
 		v-bind="questionProps"
 		:titlePlaceholder="answerType.titlePlaceholder"
 		:warningInvalid="answerType.warningInvalid"
@@ -229,7 +230,8 @@ export default defineComponent({
 	emits: [...QUESTION_EMITS, ...QUESTION_MULTIPLE_EMITS, 'update:values'],
 
 	setup(props, { emit }) {
-		const question = useQuestion(props, { emit })
+		const rootElement = ref<{ $el?: HTMLElement } | null>(null)
+		const question = useQuestion(props, { emit, rootElement })
 		const input = ref<
 			Array<{
 				focus?: () => void
@@ -388,6 +390,7 @@ export default defineComponent({
 
 		return {
 			...question,
+			rootElement,
 			...questionMultiple,
 			columns,
 			input,
diff --git a/src/components/Questions/QuestionLinearScale.vue b/src/components/Questions/QuestionLinearScale.vue
index 44c04c68d3..5cc410006d 100644
--- a/src/components/Questions/QuestionLinearScale.vue
+++ b/src/components/Questions/QuestionLinearScale.vue
@@ -5,6 +5,7 @@
 
 <template>
 	<Question
+		ref="rootElement"
 		v-bind="questionProps"
 		:titlePlaceholder="answerType.titlePlaceholder"
 		:warningInvalid="answerType.warningInvalid"
@@ -48,12 +49,12 @@
 			}">
 			<template v-if="!readOnly">
 				<label
-					:for="`q${index}__label_lowest_input`"
+					:for="`${idPrefix}__label_lowest_input`"
 					class="question-linear-scale__label-title question-linear-scale__label-title-lowest">
 					{{ t('forms', 'Label for lowest value') }}
 				</label>
 				<NcTextArea
-					:id="`q${index}__label_lowest_input`"
+					:id="`${idPrefix}__label_lowest_input`"
 					ref="lowest"
 					:modelValue="optionsLabelLowest"
 					class="question-linear-scale__label-input question-linear-scale__label-input-lowest"
@@ -105,12 +106,12 @@
 			</fieldset>
 			<template v-if="!readOnly">
 				<label
-					:for="`q${index}__label_highest_input`"
+					:for="`${idPrefix}__label_highest_input`"
 					class="question-linear-scale__label-title question-linear-scale__label-title-highest">
 					{{ t('forms', 'Label for highest value') }}
 				</label>
 				<NcTextArea
-					:id="`q${index}__label_highest_input`"
+					:id="`${idPrefix}__label_highest_input`"
 					ref="highest"
 					:modelValue="optionsLabelHighest"
 					class="question-linear-scale__label-input question-linear-scale__label-input-highest"
@@ -145,6 +146,7 @@ import Question from './Question.vue'
 import {
 	QUESTION_EMITS,
 	QUESTION_PROPS,
+	questionIdPrefix,
 	useQuestion,
 } from '../../composables/useQuestion.ts'
 
@@ -170,7 +172,8 @@ export default defineComponent({
 	emits: [...QUESTION_EMITS, 'update:values'],
 
 	setup(props, { emit }) {
-		const question = useQuestion(props, { emit })
+		const rootElement = ref<{ $el?: HTMLElement } | null>(null)
+		const question = useQuestion(props, { emit, rootElement })
 		const values = computed<string[]>(() => {
 			return props.values as string[]
 		})
@@ -242,7 +245,8 @@ export default defineComponent({
 		/**
 		 * ID for the label for the lowest option
 		 */
-		const labelId = computed(() => 'q' + props.index + '__label_lowest')
+		const idPrefix = computed(() => questionIdPrefix(props))
+		const labelId = computed(() => idPrefix.value + '__label_lowest')
 		const isUnique = computed(() => props.answerType.unique === true)
 
 		/**
@@ -328,6 +332,7 @@ export default defineComponent({
 
 		return {
 			...question,
+			rootElement,
 			IconPencil,
 			t,
 			lowest,
@@ -335,6 +340,7 @@ export default defineComponent({
 			scaleOptions,
 			isUnique,
 			questionValues,
+			idPrefix,
 			labelId,
 			optionsLowest,
 			optionsHighest,
diff --git a/src/components/Questions/QuestionList.vue b/src/components/Questions/QuestionList.vue
new file mode 100644
index 0000000000..2513b012a4
--- /dev/null
+++ b/src/components/Questions/QuestionList.vue
@@ -0,0 +1,308 @@
+<!--
+  - SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+  - SPDX-License-Identifier: AGPL-3.0-or-later
+-->
+
+<template>
+	<Draggable
+		:modelValue="modelValue"
+		:animation="animation"
+		target=".sort-target"
+		direction="vertical"
+		invertSwap
+		handle=".question__drag-handle"
+		@update:modelValue="$emit('update:modelValue', $event)"
+		@start="onDragStart"
+		@end="onDragEnd">
+		<TransitionGroup
+			tag="ul"
+			:name="isDragging ? undefined : transitionName"
+			class="sort-target">
+			<component
+				:is="getComponent(question)"
+				v-for="(question, index) in modelValue"
+				:key="question.id"
+				:ref="registerQuestionRef(question)"
+				v-bind="question"
+				:canMoveDown="index < modelValue.length - 1"
+				:canMoveUp="index > 0"
+				:answerType="getAnswerType(question)"
+				:index="isSubQuestionList ? baseIndex : baseIndex + index + 1"
+				:subIndex="isSubQuestionList ? subIndexOffset + index + 1 : null"
+				:maxStringLengths="maxStringLengths"
+				:formId="formId ?? question.formId"
+				@update:text="$emit('updateProperty', index, 'text', $event)"
+				@update:description="
+					$emit('updateProperty', index, 'description', $event)
+				"
+				@update:isRequired="
+					$emit('updateProperty', index, 'isRequired', $event)
+				"
+				@update:name="$emit('updateProperty', index, 'name', $event)"
+				@update:extraSettings="
+					$emit('updateProperty', index, 'extraSettings', $event)
+				"
+				@update:options="$emit('updateProperty', index, 'options', $event)"
+				@clone="$emit('clone', question, index)"
+				@delete="$emit('delete', question)"
+				@moveDown="$emit('moveDown', index)"
+				@moveUp="$emit('moveUp', index)">
+				<template v-if="showInsert && index < modelValue.length - 1" #insert>
+					<div
+						class="question-insert"
+						:class="[
+							{ 'is-open': insertMenuOpenedIndex === index },
+							{ 'is-mobile': isMobile },
+						]">
+						<AddQuestionMenu
+							:aria-label="
+								isSubQuestionList
+									? t(
+											'forms',
+											'Insert subquestion after question {index}',
+											{
+												index: `${baseIndex}.${subIndexOffset + index + 1}`,
+											},
+										)
+									: t(
+											'forms',
+											'Insert question after question {index}',
+											{ index: baseIndex + index + 1 },
+										)
+							"
+							variant="tertiary"
+							:position="index"
+							:isLoadingQuestions="isLoadingQuestions"
+							:answerTypesFilter="answerTypesFilter"
+							:hasSubtypes="hasSubtypes"
+							wide
+							@update:open="
+								(v) => (insertMenuOpenedIndex = v ? index : null)
+							"
+							@addQuestion="forwardAddQuestion" />
+					</div>
+				</template>
+			</component>
+		</TransitionGroup>
+	</Draggable>
+</template>
+
+<script lang="ts">
+import type { Component, ComponentPublicInstance, PropType } from 'vue'
+import type { AnswerTypeConfig } from '../../models/AnswerTypes.ts'
+import type { FormsQuestion } from '../../types/Entities.d.ts'
+
+import { t } from '@nextcloud/l10n'
+import { useIsMobile } from '@nextcloud/vue'
+import { defineComponent, nextTick, ref } from 'vue'
+import { VueDraggable as Draggable } from 'vue-draggable-plus'
+import AddQuestionMenu from '../AddQuestionMenu.vue'
+
+interface QuestionRefInstance extends ComponentPublicInstance {
+	focus?: () => void
+}
+
+export default defineComponent({
+	name: 'QuestionList',
+
+	components: {
+		AddQuestionMenu,
+		Draggable,
+	},
+
+	props: {
+		modelValue: {
+			type: Array as PropType<FormsQuestion[]>,
+			required: true,
+		},
+
+		getComponent: {
+			type: Function as PropType<(question: FormsQuestion) => Component>,
+			required: true,
+		},
+
+		getAnswerType: {
+			type: Function as PropType<
+				(question: FormsQuestion) => Partial<AnswerTypeConfig>
+			>,
+
+			required: true,
+		},
+
+		maxStringLengths: {
+			type: Object as PropType<Record<string, number>>,
+			required: true,
+		},
+
+		/** Offsets display numbering; emitted action indices remain list-local. */
+		baseIndex: {
+			type: Number,
+			default: 0,
+		},
+
+		/**
+		 * The questions are subquestions of the question at `baseIndex`
+		 */
+		isSubQuestionList: {
+			type: Boolean,
+			default: false,
+		},
+
+		/**
+		 * Number of subquestions in the previous branches of the same question
+		 */
+		subIndexOffset: {
+			type: Number,
+			default: 0,
+		},
+
+		transitionName: {
+			type: String,
+			default: 'question-list',
+		},
+
+		animation: {
+			type: Number,
+			default: 300,
+		},
+
+		showInsert: {
+			type: Boolean,
+			default: false,
+		},
+
+		answerTypesFilter: {
+			type: Object as PropType<Record<string, AnswerTypeConfig>>,
+			required: true,
+		},
+
+		hasSubtypes: {
+			type: Function as PropType<(answer: AnswerTypeConfig) => boolean>,
+			required: true,
+		},
+
+		isLoadingQuestions: {
+			type: Boolean,
+			default: false,
+		},
+
+		formId: {
+			type: Number,
+			default: null,
+		},
+	},
+
+	emits: [
+		'update:modelValue',
+		'updateProperty',
+		'clone',
+		'delete',
+		'moveDown',
+		'moveUp',
+		'addQuestion',
+	],
+
+	setup(props, { emit }) {
+		const isDragging = ref(false)
+		const insertMenuOpenedIndex = ref<number | null>(null)
+		const questionRefsMap = new Map<number, QuestionRefInstance>()
+
+		const registerQuestionRef = (
+			question: FormsQuestion,
+		): ((el: Element | ComponentPublicInstance | null) => void) => {
+			return (el) => {
+				if (el) {
+					questionRefsMap.set(question.id, el as QuestionRefInstance)
+				} else {
+					questionRefsMap.delete(question.id)
+				}
+			}
+		}
+
+		const focusQuestion = (id: number): void => {
+			questionRefsMap.get(id)?.focus?.()
+		}
+
+		const onDragStart = (): void => {
+			isDragging.value = true
+		}
+
+		const onDragEnd = (): void => {
+			nextTick(() => {
+				isDragging.value = false
+			})
+		}
+
+		/**
+		 * @param type The question type.
+		 * @param subtype The question subtype.
+		 * @param position The zero-based index of the question to insert after.
+		 */
+		const forwardAddQuestion = (
+			type: string,
+			subtype: string | null,
+			position: number | null,
+		): void => {
+			emit('addQuestion', type, subtype, position)
+		}
+
+		return {
+			isDragging,
+			insertMenuOpenedIndex,
+			registerQuestionRef,
+			focusQuestion,
+			onDragStart,
+			onDragEnd,
+			forwardAddQuestion,
+			isMobile: useIsMobile(),
+			t,
+		}
+	},
+})
+</script>
+
+<style lang="scss" scoped>
+.sort-target {
+	list-style: none;
+	padding: 0;
+	margin: 0;
+}
+
+.question-list-move,
+.question-list-enter-active,
+.question-list-leave-active {
+	transition: all var(--animation-slow) ease;
+}
+
+.question-list-enter-from,
+.question-list-leave-to {
+	opacity: 0;
+	transform: translateX(var(--clickable-area-large));
+}
+
+.question-list-leave-active {
+	position: absolute;
+}
+
+.question-insert {
+	position: relative;
+	margin-block-end: -34px;
+	inset-block-end: -16px;
+	margin-inline-start: -12px;
+	width: calc(100% - var(--default-clickable-area));
+	display: flex;
+	justify-content: center;
+	opacity: 0;
+	transition: opacity 0.12s ease;
+}
+
+.question-insert.is-mobile {
+	opacity: 0.3;
+}
+
+.question:hover > .question-insert,
+.question-insert:focus-within,
+.question-insert.is-open {
+	opacity: 1;
+}
+</style>
diff --git a/src/components/Questions/QuestionLong.vue b/src/components/Questions/QuestionLong.vue
index 507e4b51bb..a2c391a595 100644
--- a/src/components/Questions/QuestionLong.vue
+++ b/src/components/Questions/QuestionLong.vue
@@ -5,6 +5,7 @@
 
 <template>
 	<Question
+		ref="rootElement"
 		v-bind="questionProps"
 		:titlePlaceholder="answerType.titlePlaceholder"
 		:warningInvalid="answerType.warningInvalid"
@@ -59,7 +60,8 @@ export default defineComponent({
 
 	setup(props, { emit }) {
 		const textarea = ref<HTMLTextAreaElement | null>(null)
-		const question = useQuestion(props, { emit })
+		const rootElement = ref<{ $el?: HTMLElement } | null>(null)
+		const question = useQuestion(props, { emit, rootElement })
 		const values = computed(() => {
 			return props.values as Array<
 				string | number | readonly string[] | null | undefined
@@ -127,6 +129,7 @@ export default defineComponent({
 
 		return {
 			...question,
+			rootElement,
 			textarea,
 			submissionInputPlaceholder,
 			textareaValue,
diff --git a/src/components/Questions/QuestionRanking.vue b/src/components/Questions/QuestionRanking.vue
index d2bc758bf0..58c4101938 100644
--- a/src/components/Questions/QuestionRanking.vue
+++ b/src/components/Questions/QuestionRanking.vue
@@ -5,6 +5,7 @@
 
 <template>
 	<Question
+		ref="rootElement"
 		v-bind="questionProps"
 		:titlePlaceholder="answerType.titlePlaceholder"
 		:warningInvalid="answerType.warningInvalid"
@@ -244,7 +245,8 @@ export default defineComponent({
 	emits: [...QUESTION_EMITS, ...QUESTION_MULTIPLE_EMITS, 'update:values'],
 
 	setup(props, { emit }) {
-		const question = useQuestion(props, { emit })
+		const rootElement = ref<{ $el?: HTMLElement } | null>(null)
+		const question = useQuestion(props, { emit, rootElement })
 		const values = computed<Array<number | string>>(() => {
 			return Array.isArray(props.values) ? props.values : []
 		})
@@ -485,6 +487,7 @@ export default defineComponent({
 
 		return {
 			...question,
+			rootElement,
 			...questionMultiple,
 			buttonOptionDown,
 			buttonOptionUp,
diff --git a/src/components/Questions/QuestionShort.vue b/src/components/Questions/QuestionShort.vue
index a1c5a5462d..a2ac478264 100644
--- a/src/components/Questions/QuestionShort.vue
+++ b/src/components/Questions/QuestionShort.vue
@@ -5,6 +5,7 @@
 
 <template>
 	<Question
+		ref="rootElement"
 		v-bind="questionProps"
 		:titlePlaceholder="answerType.titlePlaceholder"
 		:warningInvalid="answerType.warningInvalid"
@@ -91,6 +92,7 @@ import Question from './Question.vue'
 import {
 	QUESTION_EMITS,
 	QUESTION_PROPS,
+	questionIdPrefix,
 	useQuestion,
 } from '../../composables/useQuestion.ts'
 import { INPUT_DEBOUNCE_MS } from '../../models/Constants.ts'
@@ -117,7 +119,8 @@ export default defineComponent({
 	emits: [...QUESTION_EMITS, 'update:values'],
 
 	setup(props, { emit }) {
-		const question = useQuestion(props, { emit })
+		const rootElement = ref<{ $el?: HTMLElement } | null>(null)
+		const question = useQuestion(props, { emit, rootElement })
 		const input = ref<HTMLInputElement | null>(null)
 		const regexInput = ref<{
 			$el: {
@@ -154,7 +157,7 @@ export default defineComponent({
 		 * Id of the validation type menu
 		 */
 		const validationTypeMenuId = computed(
-			() => 'q' + props.index + '__validation_menu',
+			() => questionIdPrefix(props) + '__validation_menu',
 		)
 
 		/**
@@ -299,6 +302,7 @@ export default defineComponent({
 
 		return {
 			...question,
+			rootElement,
 			IconRegex,
 			t,
 			validationTypes,
diff --git a/src/components/Results/Answer.vue b/src/components/Results/Answer.vue
index 3fe5df52f6..1db5f7e388 100644
--- a/src/components/Results/Answer.vue
+++ b/src/components/Results/Answer.vue
@@ -5,9 +5,13 @@
 
 <template>
 	<div class="answer">
-		<h4 class="answer__question-text" dir="auto">
+		<!-- Subquestions are below the heading of their conditional question -->
+		<component
+			:is="isSubQuestion ? 'h5' : 'h4'"
+			class="answer__question-text"
+			dir="auto">
 			{{ questionText }}
-		</h4>
+		</component>
 		<!-- Do not wrap the following line between tags! `white-space:pre-line` respects `\n` but would produce additional empty first line -->
 		<!-- eslint-disable-next-line -->
 		<template v-if="questionType === 'file' && answers.length">
@@ -74,6 +78,33 @@
 		<p v-else class="answer__text" dir="auto">
 			<NcHighlight :text="answerText" :search="highlight" />
 		</p>
+		<div
+			v-if="subQuestionAnswers.length > 0"
+			class="answer__subquestion"
+			role="group"
+			:aria-label="
+				t(
+					'forms',
+					'Follow-up questions of {question}',
+					{ question: questionText },
+					{ escape: false, sanitize: false },
+				)
+			">
+			<Answer
+				v-for="subquestion in subQuestionAnswers"
+				:key="subquestion.id"
+				:question="subquestion"
+				isSubQuestion
+				:highlight="highlight"
+				:answerText="subquestion.squashedAnswers"
+				:answers="subquestion.answers"
+				:questionText="subquestion.text"
+				:gridCellType="subquestion.gridCellType"
+				:gridColumns="subquestion.gridColumns"
+				:gridRows="subquestion.gridRows"
+				:gridValue="subquestion.gridValue"
+				:questionType="subquestion.type" />
+		</div>
 	</div>
 </template>
 
@@ -82,11 +113,25 @@ import type { PropType } from 'vue'
 import type { FormsOption } from '../../types/Entities.d.ts'
 
 import IconFile from '@material-symbols/svg-400/outlined/draft.svg?raw'
-import { defineComponent } from 'vue'
+import { t } from '@nextcloud/l10n'
+import { computed, defineComponent } from 'vue'
 import NcCheckboxRadioSwitch from '@nextcloud/vue/components/NcCheckboxRadioSwitch'
 import NcHighlight from '@nextcloud/vue/components/NcHighlight'
 import NcIconSvgWrapper from '@nextcloud/vue/components/NcIconSvgWrapper'
 
+export interface AnsweredQuestion {
+	id: number
+	text: string
+	type: string
+	squashedAnswers?: string
+	answers?: Array<{ id: number; text: string; url?: string }>
+	branchAnswers?: AnsweredQuestion[][]
+	gridValue?: Record<string, string | string[] | Record<string, string | number>>
+	gridCellType?: string
+	gridRows?: FormsOption[]
+	gridColumns?: FormsOption[]
+}
+
 export default defineComponent({
 	// eslint-disable-next-line vue/multi-word-component-names
 	name: 'Answer',
@@ -97,6 +142,16 @@ export default defineComponent({
 	},
 
 	props: {
+		question: {
+			type: Object as PropType<AnsweredQuestion>,
+			required: true,
+		},
+
+		isSubQuestion: {
+			type: Boolean,
+			default: false,
+		},
+
 		answers: {
 			type: Array as PropType<
 				Array<{ id: number; text: string; url?: string }>
@@ -175,9 +230,16 @@ export default defineComponent({
 			return row ?? ''
 		}
 
+		// The answered subquestions of all branches
+		const subQuestionAnswers = computed(() =>
+			(props.question.branchAnswers ?? []).flat(),
+		)
+
 		return {
 			IconFile,
 			getGridNumberValue,
+			subQuestionAnswers,
+			t,
 		}
 	},
 })
@@ -244,5 +306,16 @@ export default defineComponent({
 			inset-inline-start: 0;
 		}
 	}
+
+	&__subquestion {
+		margin-top: 16px;
+		padding-left: 16px;
+		border-left: 3px solid var(--color-primary-element);
+
+		// Phones have little width to spare, the border still shows the nesting
+		@media (max-width: 768px) {
+			padding-left: 8px;
+		}
+	}
 }
 </style>
diff --git a/src/components/Results/Submission.vue b/src/components/Results/Submission.vue
index c2b780ca93..943a497d97 100644
--- a/src/components/Results/Submission.vue
+++ b/src/components/Results/Submission.vue
@@ -36,6 +36,7 @@
 		<Answer
 			v-for="question in answeredQuestions"
 			:key="question.id"
+			:question="question"
 			:highlight="highlight"
 			:answerText="question.squashedAnswers"
 			:answers="question.answers"
@@ -55,6 +56,7 @@ import type {
 	FormsQuestion,
 	FormsSubmission,
 } from '../../types/Entities.d.ts'
+import type { AnsweredQuestion } from './Answer.vue'
 
 import IconDelete from '@material-symbols/svg-400/outlined/delete.svg?raw'
 import IconPencil from '@material-symbols/svg-400/outlined/edit.svg?raw'
@@ -69,18 +71,6 @@ import NcIconSvgWrapper from '@nextcloud/vue/components/NcIconSvgWrapper'
 import Answer from './Answer.vue'
 import { OptionType } from '../../models/Constants.ts'
 
-interface AnsweredQuestion {
-	id: number
-	text: string
-	type: string
-	squashedAnswers?: string
-	answers?: Array<{ id: number; text: string; url?: string }>
-	gridValue?: Record<string, string | string[] | Record<string, string | number>>
-	gridCellType?: string
-	gridRows?: FormsOption[]
-	gridColumns?: FormsOption[]
-}
-
 export default defineComponent({
 	// eslint-disable-next-line vue/multi-word-component-names
 	name: 'Submission',
@@ -191,12 +181,13 @@ export default defineComponent({
 		 * Join answered Questions with corresponding answers.
 		 * Multiple answers to a question are squashed into one string.
 		 *
-		 * @return
+		 * @param questions - Questions to match with submission answers
+		 * @return Questions with their answers prepared for display
 		 */
-		const answeredQuestions = computed<AnsweredQuestion[]>(() => {
+		const parseQuestions = (questions: FormsQuestion[]): AnsweredQuestion[] => {
 			const answeredQuestionsArray: AnsweredQuestion[] = []
 
-			props.questions.forEach((question) => {
+			questions.forEach((question) => {
 				const answers = props.submission.answers.filter(
 					(answer) => answer.questionId === question.id,
 				)
@@ -300,6 +291,21 @@ export default defineComponent({
 							(option) => option.optionType === OptionType.Column,
 						),
 					})
+				} else if (question.type === 'conditional') {
+					const branches = question.extraSettings?.branches ?? []
+					const triggerType = question.extraSettings?.triggerType
+					if (!branches.length || !triggerType) {
+						return
+					}
+					const [triggerQuestion] = parseQuestions([
+						{ ...question, type: triggerType },
+					])
+					answeredQuestionsArray.push({
+						...triggerQuestion,
+						branchAnswers: branches.map((branch) =>
+							parseQuestions(branch.subQuestions),
+						),
+					})
 				} else if (['date', 'time'].includes(question.type)) {
 					const squashedAnswers = answers
 						.map((answer) => answer.text)
@@ -348,7 +354,9 @@ export default defineComponent({
 				}
 			})
 			return answeredQuestionsArray
-		})
+		}
+
+		const answeredQuestions = computed(() => parseQuestions(props.questions))
 
 		const onDelete = (): void => {
 			emit('delete')
diff --git a/src/composables/useQuestion.ts b/src/composables/useQuestion.ts
index c7a140bf14..6992f3e842 100644
--- a/src/composables/useQuestion.ts
+++ b/src/composables/useQuestion.ts
@@ -30,6 +30,34 @@ export const QUESTION_EMITS = [
 	'moveUp',
 ]
 
+/**
+ * Prefix for the element ids of a question, unique for subquestions as well
+ *
+ * @param props question props
+ * @param props.index position of the question in the form
+ * @param props.subIndex position of a subquestion within its branch
+ */
+export function questionIdPrefix(props: {
+	index?: number
+	subIndex?: number | null
+}): string {
+	return props.subIndex ? `q${props.index}_${props.subIndex}` : `q${props.index}`
+}
+
+/**
+ * Number of a question as announced to users, e.g. "2" or "2.1" for a subquestion
+ *
+ * @param props question props
+ * @param props.index position of the question in the form
+ * @param props.subIndex position of a subquestion within its branch
+ */
+export function questionNumber(props: {
+	index?: number
+	subIndex?: number | null
+}): string {
+	return props.subIndex ? `${props.index}.${props.subIndex}` : `${props.index}`
+}
+
 export const QUESTION_PROPS = {
 	id: {
 		type: Number,
@@ -47,6 +75,10 @@ export const QUESTION_PROPS = {
 		type: String,
 		required: true,
 	},
+	isTriggerQuestion: {
+		type: Boolean,
+		default: false,
+	},
 	isRequired: {
 		type: Boolean,
 		required: true,
@@ -55,6 +87,20 @@ export const QUESTION_PROPS = {
 		type: Number,
 		required: true,
 	},
+	// Position of a subquestion within its branch, `index` is then the one of the conditional question
+	subIndex: {
+		type: Number,
+		default: null,
+	},
+	// Subquestions are bound with their place, which must not end up as attributes
+	parentQuestionId: {
+		type: Number,
+		default: null,
+	},
+	branchId: {
+		type: String,
+		default: null,
+	},
 	name: {
 		type: String,
 		default: '',
@@ -124,8 +170,10 @@ interface QuestionPropsLike {
 	id: number
 	formId: number | null
 	index: number
+	subIndex?: number | null
 	text: string
 	description: string
+	isTriggerQuestion: boolean
 	isRequired: boolean
 	readOnly: boolean
 	name: string
@@ -139,8 +187,10 @@ interface QuestionPropsLike {
 
 interface QuestionForwardedProps {
 	index: number
+	subIndex: number | null
 	text: string
 	description: string
+	isTriggerQuestion: boolean
 	isRequired: boolean
 	readOnly: boolean
 	maxStringLengths: Record<string, number>
@@ -160,8 +210,10 @@ export function useQuestion(props: QuestionPropsLike, options: UseQuestionOption
 
 	const questionProps = computed<QuestionForwardedProps>(() => ({
 		index: props.index,
+		subIndex: props.subIndex ?? null,
 		text: props.text,
 		description: props.description,
+		isTriggerQuestion: props.isTriggerQuestion,
 		isRequired: props.isRequired,
 		readOnly: props.readOnly,
 		maxStringLengths: props.maxStringLengths,
@@ -171,11 +223,11 @@ export function useQuestion(props: QuestionPropsLike, options: UseQuestionOption
 	}))
 
 	const titleId = computed(() => {
-		return 'q' + props.index + '_title'
+		return questionIdPrefix(props) + '_title'
 	})
 
 	const descriptionId = computed(() => {
-		return 'q' + props.index + '_desc'
+		return questionIdPrefix(props) + '_desc'
 	})
 
 	const hasError = computed(() => {
@@ -187,11 +239,11 @@ export function useQuestion(props: QuestionPropsLike, options: UseQuestionOption
 	})
 
 	const errorId = computed(() => {
-		return `q${props.index}_error`
+		return `${questionIdPrefix(props)}${props.isTriggerQuestion ? '_trigger' : ''}_error`
 	})
 
 	const infoId = computed(() => {
-		return `q${props.index}_info`
+		return `${questionIdPrefix(props)}${props.isTriggerQuestion ? '_trigger' : ''}_info`
 	})
 
 	const onTitleChange = debounce(function (text: string) {
@@ -214,7 +266,23 @@ export function useQuestion(props: QuestionPropsLike, options: UseQuestionOption
 	) {
 		const newExtraSettings = { ...props.extraSettings, ...newSettings }
 		options.emit('update:extraSettings', newExtraSettings)
-		saveQuestionProperty('extraSettings', newExtraSettings)
+		const persistedExtraSettings =
+			props.type === 'conditional'
+				? {
+						...newExtraSettings,
+						branches: Array.isArray(newExtraSettings.branches)
+							? newExtraSettings.branches.map((branch) => {
+									const settings = { ...branch }
+									delete settings.subQuestions
+									return settings
+								})
+							: [],
+					}
+				: newExtraSettings
+		// Embedded triggers share their parent's ID; the parent owns persistence.
+		if (!props.isTriggerQuestion) {
+			saveQuestionProperty('extraSettings', persistedExtraSettings)
+		}
 	}, INPUT_DEBOUNCE_MS)
 
 	const onNameChange = debounce(function (name: string) {
diff --git a/src/models/AnswerTypes.ts b/src/models/AnswerTypes.ts
index e2bc47b9ea..b34f941c60 100644
--- a/src/models/AnswerTypes.ts
+++ b/src/models/AnswerTypes.ts
@@ -1,5 +1,5 @@
 /**
- * SPDX-FileCopyrightText: 2020 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2020-2026 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
@@ -7,6 +7,7 @@ import type { Component } from 'vue'
 import type { FormsOption, FormsQuestion } from '../types/Entities.d.ts'
 
 import IconNumeric from '@material-symbols/svg-400/outlined/123.svg?raw'
+import IconSourceBranch from '@material-symbols/svg-400/outlined/account_tree.svg?raw'
 import IconArrowDownDropCircleOutline from '@material-symbols/svg-400/outlined/arrow_drop_down_circle.svg?raw'
 import IconCalendar from '@material-symbols/svg-400/outlined/calendar_today.svg?raw'
 import IconCheckboxOutline from '@material-symbols/svg-400/outlined/check_box.svg?raw'
@@ -22,6 +23,7 @@ import IconSwapVertical from '@material-symbols/svg-400/outlined/swap_vert.svg?r
 import { t } from '@nextcloud/l10n'
 import { markRaw } from 'vue'
 import QuestionColor from '../components/Questions/QuestionColor.vue'
+import QuestionConditional from '../components/Questions/QuestionConditional.vue'
 import QuestionDate from '../components/Questions/QuestionDate.vue'
 import QuestionDropdown from '../components/Questions/QuestionDropdown.vue'
 import QuestionFile from '../components/Questions/QuestionFile.vue'
@@ -296,6 +298,28 @@ const answerTypes: Record<string, AnswerTypeConfig> = {
 			'This question needs a title and at least one answer!',
 		),
 	},
+
+	conditional: {
+		component: markRaw(QuestionConditional),
+		icon: IconSourceBranch,
+		label: t('forms', 'Conditional'),
+		predefined: true,
+		validate: (question) => {
+			// Must have a trigger type and at least one branch
+			const extraSettings = question.extraSettings || {}
+			return (
+				!!extraSettings.triggerType
+				&& (extraSettings.branches?.length ?? 0) > 0
+			)
+		},
+
+		titlePlaceholder: t('forms', 'Conditional question title'),
+		createPlaceholder: t('forms', 'Different questions based on the answer'),
+		warningInvalid: t(
+			'forms',
+			'This question needs a title, trigger type, and at least one branch!',
+		),
+	},
 }
 
 export default answerTypes
diff --git a/src/types/Entities.d.ts b/src/types/Entities.d.ts
index 1d9b26248d..6228bffd58 100644
--- a/src/types/Entities.d.ts
+++ b/src/types/Entities.d.ts
@@ -39,7 +39,15 @@ export interface FormsSubmission {
 	userDisplayName: string
 }
 
+export interface FormsConditionalBranch {
+	id: string
+	conditions: Record<string, unknown>[]
+	subQuestions: FormsQuestion[]
+}
+
 export interface FormsQuestionExtraSettings {
+	triggerType?: string | null
+	branches?: FormsConditionalBranch[]
 	allowOtherAnswer?: boolean
 	shuffleOptions?: boolean
 	optionsLimitMax?: number
@@ -67,6 +75,8 @@ export interface FormsQuestionExtraSettings {
 export interface FormsQuestion {
 	id: number
 	formId?: number | null
+	parentQuestionId?: number | null
+	branchId?: string | null
 	text: string
 	type: string
 	order?: number | null
diff --git a/src/views/Create.vue b/src/views/Create.vue
index 696dd03c81..c3fbdf4b0b 100644
--- a/src/views/Create.vue
+++ b/src/views/Create.vue
@@ -114,87 +114,24 @@
 
 			<section>
 				<!-- Questions list -->
-				<Draggable
+				<QuestionList
+					ref="questionList"
 					:modelValue="form.questions"
-					:animation="300"
-					target=".sort-target"
-					direction="vertical"
-					invertSwap
-					handle=".question__drag-handle"
+					:getComponent="getQuestionComponent"
+					:getAnswerType="getQuestionAnswerType"
+					:maxStringLengths="maxStringLengths"
+					:formId="form.id"
+					:showInsert="true"
+					:answerTypesFilter="answerTypesFilter"
+					:hasSubtypes="hasSubtypes"
+					:isLoadingQuestions="isLoadingQuestions"
 					@update:modelValue="onUpdateQuestions"
-					@start="onDragStart"
-					@end="onDragEnd">
-					<TransitionGroup
-						tag="ul"
-						:name="isDragging ? undefined : 'question-list'"
-						class="sort-target">
-						<component
-							:is="answerTypes[question.type].component"
-							v-for="(question, index) in form.questions"
-							:key="question.id"
-							:ref="registerQuestionRef(question)"
-							v-bind="form.questions[index]"
-							:canMoveDown="index < form.questions.length - 1"
-							:canMoveUp="index > 0"
-							:answerType="answerTypes[question.type]"
-							:index="index + 1"
-							:maxStringLengths="maxStringLengths"
-							@update:text="updateQuestionText(index, $event)"
-							@update:description="
-								updateQuestionDescription(index, $event)
-							"
-							@update:isRequired="
-								updateQuestionIsRequired(index, $event)
-							"
-							@update:name="updateQuestionName(index, $event)"
-							@update:extraSettings="
-								updateQuestionExtraSettings(index, $event)
-							"
-							@update:options="updateQuestionOptions(index, $event)"
-							@clone="cloneQuestion(question, index)"
-							@delete="deleteQuestion(question.id)"
-							@moveDown="onMoveDown(index)"
-							@moveUp="onMoveUp(index)">
-							<template
-								v-if="index < form.questions.length - 1"
-								#insert>
-								<div
-									class="question-insert"
-									:class="[
-										{
-											'is-open':
-												insertMenuOpenedIndex === index,
-										},
-										{
-											'is-mobile': isMobile,
-										},
-									]">
-									<AddQuestionMenu
-										:aria-label="
-											t(
-												'forms',
-												'Insert question after question {index}',
-												{ index: index + 1 },
-											)
-										"
-										variant="tertiary"
-										:position="index"
-										:isLoadingQuestions="isLoadingQuestions"
-										:answerTypesFilter="answerTypesFilter"
-										:hasSubtypes="hasSubtypes"
-										wide
-										@update:open="
-											(v) =>
-												(insertMenuOpenedIndex = v
-													? index
-													: null)
-										"
-										@addQuestion="addQuestion" />
-								</div>
-							</template>
-						</component>
-					</TransitionGroup>
-				</Draggable>
+					@updateProperty="updateQuestionProperty"
+					@clone="cloneQuestion"
+					@delete="(question) => deleteQuestion(question.id)"
+					@moveDown="onMoveDown"
+					@moveUp="onMoveUp"
+					@addQuestion="addQuestion" />
 
 				<!-- Add new questions menu -->
 				<div class="question-menu">
@@ -214,8 +151,8 @@
 </template>
 
 <script lang="ts">
-import type { ComponentPublicInstance, PropType } from 'vue'
-import type { FormsForm, FormsOption, FormsQuestion } from '../types/Entities.d.ts'
+import type { PropType } from 'vue'
+import type { FormsForm, FormsQuestion } from '../types/Entities.d.ts'
 
 import IconLock from '@material-symbols/svg-400/outlined/lock.svg?raw'
 import axios from '@nextcloud/axios'
@@ -225,20 +162,14 @@ import { loadState } from '@nextcloud/initial-state'
 import { t } from '@nextcloud/l10n'
 import moment from '@nextcloud/moment'
 import { generateOcsUrl } from '@nextcloud/router'
-import { useIsMobile } from '@nextcloud/vue'
 import debounce from 'debounce'
 import { computed, defineComponent, nextTick, onMounted, ref, watch } from 'vue'
-import { VueDraggable as Draggable } from 'vue-draggable-plus'
 import NcAppContent from '@nextcloud/vue/components/NcAppContent'
 import NcEmptyContent from '@nextcloud/vue/components/NcEmptyContent'
 import NcIconSvgWrapper from '@nextcloud/vue/components/NcIconSvgWrapper'
 import NcLoadingIcon from '@nextcloud/vue/components/NcLoadingIcon'
-import NcNoteCard from '@nextcloud/vue/components/NcNoteCard'
 import AddQuestionMenu from '../components/AddQuestionMenu.vue'
-import Question from '../components/Questions/Question.vue'
-import QuestionLong from '../components/Questions/QuestionLong.vue'
-import QuestionMultiple from '../components/Questions/QuestionMultiple.vue'
-import QuestionShort from '../components/Questions/QuestionShort.vue'
+import QuestionList from '../components/Questions/QuestionList.vue'
 import TopBar from '../components/TopBar.vue'
 import { useViewForm } from '../composables/useViewForm.ts'
 import answerTypes from '../models/AnswerTypes.ts'
@@ -249,27 +180,18 @@ import SetWindowTitle from '../utils/SetWindowTitle.ts'
 
 const formsAppName = 'forms'
 
-interface QuestionRefInstance extends ComponentPublicInstance {
-	focus?: () => void
-}
-
 ;(window as Window & { axios?: typeof axios }).axios = axios
 
 export default defineComponent({
 	// eslint-disable-next-line vue/multi-word-component-names
 	name: 'Create',
 	components: {
-		Draggable,
 		NcIconSvgWrapper,
 		AddQuestionMenu,
 		NcAppContent,
 		NcEmptyContent,
 		NcLoadingIcon,
-		NcNoteCard,
-		Question,
-		QuestionLong,
-		QuestionShort,
-		QuestionMultiple,
+		QuestionList,
 		TopBar,
 	},
 
@@ -295,6 +217,7 @@ export default defineComponent({
 	setup(props, { emit }) {
 		const title = ref<HTMLTextAreaElement | null>(null)
 		const description = ref<HTMLTextAreaElement | null>(null)
+		const questionList = ref<InstanceType<typeof QuestionList> | null>(null)
 		const viewForm = useViewForm({
 			form: () => props.form,
 			emit,
@@ -303,38 +226,11 @@ export default defineComponent({
 
 		// Various states
 		const isLoadingQuestions = ref<boolean>(false)
-		const isDragging = ref<boolean>(false)
 		const maxStringLengths = loadState(
 			formsAppName,
 			'maxStringLengths',
 		) as Record<string, number>
 		const questionMenuOpened = ref<boolean>(false)
-		const activeQuestionType = ref<string | null>(null)
-		const questionRefsMap = ref<Record<number, QuestionRefInstance>>({})
-		// when set to a number, the next created question will be inserted at this index
-		const insertMenuOpenedIndex = ref<number | null>(null)
-		// controls per-question insert menu visibility
-		const insertMenuOpened = ref<boolean>(false)
-
-		// Helper functions
-		const setQuestionRef = (
-			el: QuestionRefInstance | null,
-			question: FormsQuestion,
-		): void => {
-			if (el) {
-				questionRefsMap.value[question.id] = el
-			} else {
-				delete questionRefsMap.value[question.id]
-			}
-		}
-
-		const registerQuestionRef = (
-			question: FormsQuestion,
-		): ((el: Element | ComponentPublicInstance | null) => void) => {
-			return (el) => {
-				setQuestionRef(el as QuestionRefInstance | null, question)
-			}
-		}
 
 		/**
 		 * Auto adjust the title height based its scroll height
@@ -463,21 +359,17 @@ export default defineComponent({
 				&& Object.keys(answer?.subtypes ?? {}).length > 0
 		})
 
+		const getQuestionComponent = (question: FormsQuestion) =>
+			answerTypes[question.type].component
+
+		const getQuestionAnswerType = (question: FormsQuestion) =>
+			answerTypes[question.type]
+
 		const lockedUntilFormatted = computed<string>(() =>
 			moment(props.form.lockedUntil, 'X').fromNow(),
 		)
 
 		// Event handlers
-		const onDragStart = (): void => {
-			isDragging.value = true
-		}
-
-		const onDragEnd = (): void => {
-			nextTick(() => {
-				isDragging.value = false
-			})
-		}
-
 		const updateQuestionProperty = <K extends keyof FormsQuestion>(
 			index: number,
 			property: K,
@@ -488,36 +380,6 @@ export default defineComponent({
 			emit('update:form', { ...props.form, questions })
 		}
 
-		const updateQuestionText = (index: number, value: string): void => {
-			updateQuestionProperty(index, 'text', value)
-		}
-
-		const updateQuestionDescription = (index: number, value: string): void => {
-			updateQuestionProperty(index, 'description', value)
-		}
-
-		const updateQuestionIsRequired = (index: number, value: boolean): void => {
-			updateQuestionProperty(index, 'isRequired', value)
-		}
-
-		const updateQuestionName = (index: number, value: string): void => {
-			updateQuestionProperty(index, 'name', value)
-		}
-
-		const updateQuestionExtraSettings = (
-			index: number,
-			value: Record<string, unknown> | null,
-		): void => {
-			updateQuestionProperty(index, 'extraSettings', value)
-		}
-
-		const updateQuestionOptions = (
-			index: number,
-			value: FormsOption[],
-		): void => {
-			updateQuestionProperty(index, 'options', value)
-		}
-
 		/**
 		 * Reorder questions on dragEnd
 		 *
@@ -590,18 +452,13 @@ export default defineComponent({
 			const questions = [...props.form.questions]
 			if (insertAt !== null && insertAt <= questions.length) {
 				questions.splice(insertAt, 0, newQuestionObj)
-				emit('update:form', { ...props.form, questions })
-				nextTick(() => {
-					// Prefer ref by id when available, fallback to positional refs
-					questionRefsMap.value[newQuestionObj.id]?.focus?.()
-				})
 			} else {
 				questions.push(newQuestionObj)
-				emit('update:form', { ...props.form, questions })
-				nextTick(() => {
-					questionRefsMap.value[newQuestionObj.id]?.focus?.()
-				})
 			}
+			emit('update:form', { ...props.form, questions })
+			nextTick(() => {
+				questionList.value?.focusQuestion(newQuestionObj.id)
+			})
 
 			emitEvent('forms:last-updated:set', props.form.id)
 		}
@@ -646,7 +503,6 @@ export default defineComponent({
 			subtype: string | null = null,
 			position: number | null = null,
 		): Promise<void> => {
-			activeQuestionType.value = null
 			const text = ''
 			isLoadingQuestions.value = true
 
@@ -801,17 +657,12 @@ export default defineComponent({
 
 		return {
 			...viewForm,
-			answerTypes,
 			title,
 			description,
+			questionList,
 			isLoadingQuestions,
-			isDragging,
 			maxStringLengths,
 			questionMenuOpened,
-			activeQuestionType,
-			questionRefsMap,
-			insertMenuOpenedIndex,
-			insertMenuOpened,
 			hasQuestions,
 			isRequiredUsed,
 			isExpired,
@@ -820,17 +671,10 @@ export default defineComponent({
 			expirationMessage,
 			answerTypesFilter,
 			hasSubtypes,
+			getQuestionComponent,
+			getQuestionAnswerType,
 			lockedUntilFormatted,
-			onDragStart,
-			onDragEnd,
-			setQuestionRef,
-			registerQuestionRef,
-			updateQuestionText,
-			updateQuestionDescription,
-			updateQuestionIsRequired,
-			updateQuestionName,
-			updateQuestionExtraSettings,
-			updateQuestionOptions,
+			updateQuestionProperty,
 			onMoveUp,
 			onMoveDown,
 			onTitleInput,
@@ -844,7 +688,6 @@ export default defineComponent({
 			onUpdateQuestions,
 			onQuestionOrderChange,
 			IconLock,
-			isMobile: useIsMobile(),
 			t,
 		}
 	},
@@ -948,45 +791,4 @@ export default defineComponent({
 		}
 	}
 }
-
-.question-list-move,
-.question-list-enter-active,
-.question-list-leave-active {
-	transition: all var(--animation-slow) ease;
-}
-
-.question-list-enter-from,
-.question-list-leave-to {
-	opacity: 0;
-	transform: translateX(var(--clickable-area-large));
-}
-
-/* ensure leaving items are taken out of layout flow so that moving
-   animations can be calculated correctly. */
-.question-list-leave-active {
-	position: absolute;
-}
-
-.question-insert {
-	/* closer to the question above */
-	position: relative;
-	margin-block-end: -34px;
-	inset-block-end: -16px;
-	margin-inline-start: -12px;
-	width: calc(100% - var(--default-clickable-area));
-	display: flex;
-	justify-content: center;
-	opacity: 0;
-	transition: opacity 0.12s ease;
-}
-
-.question-insert.is-mobile {
-	opacity: 0.3;
-}
-
-.question:hover > .question-insert,
-.question-insert:focus-within,
-.question-insert.is-open {
-	opacity: 1;
-}
 </style>
diff --git a/src/views/Results.vue b/src/views/Results.vue
index 566359ce10..ee239d4d85 100644
--- a/src/views/Results.vue
+++ b/src/views/Results.vue
@@ -229,7 +229,7 @@
 		<!-- Summary view for visualization -->
 		<section v-else-if="isSummaryView">
 			<ResultsSummary
-				v-for="question in questions"
+				v-for="question in summaryQuestions"
 				:key="question.id"
 				:question="question"
 				:submissions="submissions" />
@@ -430,6 +430,33 @@ export default defineComponent({
 		const viewForm = useViewForm({ form: () => props.form, emit })
 
 		const questions = ref<FormsQuestion[]>([])
+
+		/**
+		 * List the trigger of a conditional question as a question of its trigger type,
+		 * followed by the subquestions of all its branches
+		 *
+		 * @param formQuestions The questions of the form
+		 */
+		const flattenQuestions = (formQuestions: FormsQuestion[]): FormsQuestion[] =>
+			formQuestions.flatMap((question) => {
+				const triggerType = question.extraSettings?.triggerType
+				if (question.type !== 'conditional' || !triggerType) {
+					return [question]
+				}
+				return [
+					{ ...question, type: triggerType },
+					...(question.extraSettings?.branches ?? []).flatMap(
+						(branch) => branch.subQuestions ?? [],
+					),
+				]
+			})
+
+		/**
+		 * Questions to summarize, subquestions and triggers like other questions
+		 */
+		const summaryQuestions = computed<FormsQuestion[]>(() =>
+			flattenQuestions(questions.value),
+		)
 		const submissions = ref<FormsSubmission[]>([])
 		const filteredSubmissionsCount = ref(0)
 		const isDownloadActionOpened = ref(false)
@@ -646,9 +673,10 @@ export default defineComponent({
 				}
 				const data = OcsResponse2Data<ResultsResponse>(response)
 
+				// Answers of subquestions and triggers are dates as well
 				submissions.value = formatDateAnswers(
 					data.submissions,
-					data.questions,
+					flattenQuestions(data.questions),
 				) as FormsSubmission[]
 				questions.value = data.questions
 				filteredSubmissionsCount.value = data.filteredSubmissionsCount
@@ -1074,6 +1102,7 @@ export default defineComponent({
 			t,
 			responseViews,
 			questions,
+			summaryQuestions,
 			submissions,
 			filteredSubmissionsCount,
 			isDownloadActionOpened,
diff --git a/src/views/Submit.vue b/src/views/Submit.vue
index fcc4943108..a7ca0062ed 100644
--- a/src/views/Submit.vue
+++ b/src/views/Submit.vue
@@ -1,5 +1,5 @@
 <!--
-  - SPDX-FileCopyrightText: 2020 Nextcloud GmbH and Nextcloud contributors
+  - SPDX-FileCopyrightText: 2020-2026 Nextcloud GmbH and Nextcloud contributors
   - SPDX-License-Identifier: AGPL-3.0-or-later
 -->
 
@@ -150,9 +150,7 @@
 						:values="answers[question.id]"
 						@keydown.enter="onKeydownEnter"
 						@keydown.ctrl.enter="onKeydownCtrlEnter"
-						@update:values="
-							(values: AnswerValue) => onUpdate(question, values)
-						" />
+						@update:values="onUpdate(question, $event)" />
 				</ul>
 				<div class="form-buttons">
 					<NcButton
@@ -228,11 +226,7 @@
 </template>
 
 <script lang="ts">
-import type {
-	FormsOption,
-	FormsQuestion,
-	GridQuestionValues,
-} from '../types/Entities.d.ts'
+import type { FormsQuestion, GridQuestionValues } from '../types/Entities.d.ts'
 
 import IconCancel from '@material-symbols/svg-400/outlined/block.svg?raw'
 import IconCheck from '@material-symbols/svg-400/outlined/check.svg?raw'
@@ -287,7 +281,12 @@ import SetWindowTitle from '../utils/SetWindowTitle.ts'
 
 const formsAppName = 'forms'
 
-type AnswerValue = string[] | GridQuestionValues
+interface ConditionalAnswerValue {
+	trigger: string[]
+	subQuestions: Record<number, string[]>
+}
+
+type AnswerValue = string[] | GridQuestionValues | ConditionalAnswerValue
 type AnswersMap = Record<number, AnswerValue>
 
 interface StoredAnswerState {
@@ -299,14 +298,6 @@ interface StoredAnswersMap {
 	[key: string]: StoredAnswerState
 }
 
-interface SubmitQuestion extends FormsQuestion {
-	options?: FormsOption[]
-	extraSettings?: Record<string, unknown> & {
-		allowOtherAnswer?: boolean
-	}
-	isRequired?: boolean
-}
-
 interface LoadedSubmissionAnswer {
 	id: number
 	questionId: number | string
@@ -415,7 +406,7 @@ export default defineComponent({
 		const showClearFormDueToChangeDialog = ref(false)
 		const confirmButtonCallback = ref<(val: boolean) => void>(() => {})
 
-		const validQuestions = computed<SubmitQuestion[]>(() => {
+		const validQuestions = computed<FormsQuestion[]>(() => {
 			return props.form.questions.filter((question: FormsQuestion) => {
 				// All questions must have a valid title
 				if (question.text?.trim() === '') {
@@ -428,7 +419,7 @@ export default defineComponent({
 					return answerType.validate(question)
 				}
 				return true
-			}) as SubmitQuestion[]
+			}) as FormsQuestion[]
 		})
 
 		const validQuestionsIds = computed<Set<number>>(() => {
@@ -644,12 +635,26 @@ export default defineComponent({
 					continue
 				}
 
-				localAnswers[parseInt(questionId, 10)] = [
-					'QuestionMultiple',
-					'QuestionRanking',
-				].includes(answer.type)
-					? (answer.value as string[]).map(String)
-					: answer.value
+				if (
+					['QuestionMultiple', 'QuestionRanking'].includes(answer.type)
+					&& Array.isArray(answer.value)
+				) {
+					localAnswers[parseInt(questionId, 10)] = answer.value.map(String)
+				} else if (answer.type === 'QuestionConditional') {
+					// Restore conditional answer structure with proper type conversions
+					const value = Array.isArray(answer.value)
+						? undefined
+						: (answer.value as Partial<ConditionalAnswerValue>)
+					localAnswers[parseInt(questionId, 10)] = {
+						trigger: Array.isArray(value?.trigger)
+							? value.trigger.map(String)
+							: [],
+
+						subQuestions: value?.subQuestions || {},
+					}
+				} else {
+					localAnswers[parseInt(questionId, 10)] = answer.value
+				}
 			}
 			answers.value = localAnswers
 		}
@@ -659,7 +664,7 @@ export default defineComponent({
 		 *
 		 * @param question Question to update
 		 */
-		function addFormFieldToLocalStorage(question: SubmitQuestion): void {
+		function addFormFieldToLocalStorage(question: FormsQuestion): void {
 			if (!props.isLoggedIn) {
 				return
 			}
@@ -739,34 +744,45 @@ export default defineComponent({
 				const loaded: AnswersMap = {}
 				const loadedAnswers =
 					OcsResponse2Data<LoadedSubmissionResponse>(response).answers
-				for (const answer of loadedAnswers) {
-					const questionId = Number(answer.questionId)
-					const text = answer.text
 
-					// Only initialize once, don't overwrite previous answers
-					if (!loaded[questionId]) {
-						loaded[questionId] = []
+				/**
+				 * Reuse conditional state regardless of trigger/subquestion answer order.
+				 *
+				 * @param questionId The conditional question ID.
+				 */
+				function getConditionalAnswer(
+					questionId: number,
+				): ConditionalAnswerValue {
+					const value = loaded[questionId]
+					if (value && !Array.isArray(value) && 'trigger' in value) {
+						return value as ConditionalAnswerValue
 					}
-					// Grid answers get replaced by a values-object below, all
-					// other question types collect their answers in this list
-					const questionAnswers = loaded[questionId] as string[]
-
-					logger.debug(`questionId: ${questionId}, answerId: ${answer.id}`)
-					// Clean up answers for questions that do not exist anymore
-					if (!validQuestionsIds.value.has(questionId)) {
-						showClearFormDueToChangeDialog.value = true
-						logger.debug('Question does not exist anymore', {
-							questionId,
-						})
-						continue
+					const conditionalAnswer: ConditionalAnswerValue = {
+						trigger: [],
+						subQuestions: {},
 					}
+					loaded[questionId] = conditionalAnswer
+					return conditionalAnswer
+				}
+
+				/**
+				 * Restore a stored answer text to the values the question component expects
+				 *
+				 * @param question The question, the trigger of a conditional question with the trigger type
+				 * @param text The stored answer text
+				 * @param values The values restored so far for this question
+				 * @return The values of the question
+				 */
+				function restoreAnswer(
+					question: FormsQuestion,
+					text: string,
+					values: AnswerValue = [],
+				): AnswerValue {
+					const questionId = question.id
+					// Grid answers are returned as a values-object, all
+					// other question types collect their answers in this list
+					const questionAnswers = values as string[]
 
-					const question = props.form.questions.find(
-						(question: FormsQuestion) => question.id === questionId,
-					) as SubmitQuestion | undefined
-					if (!question) {
-						continue
-					}
 					if (question.type === 'ranking') {
 						try {
 							questionAnswers.push(...JSON.parse(text).map(String))
@@ -826,7 +842,7 @@ export default defineComponent({
 									restoredValues[Number(rowId)] = rowValue
 								}
 							}
-							loaded[questionId] = restoredValues
+							return restoredValues
 						} catch (error) {
 							logger.debug(
 								`Could not parse grid answer ${text} for question ${questionId}`,
@@ -871,6 +887,83 @@ export default defineComponent({
 					} else {
 						questionAnswers.push(text)
 					}
+					return questionAnswers
+				}
+
+				// Build a map of subquestion ID → subquestion and its conditional question ID
+				const subQuestions = new Map<
+					number,
+					{ conditionalId: number; subQuestion: FormsQuestion }
+				>()
+				for (const question of props.form.questions as FormsQuestion[]) {
+					if (question.type === 'conditional') {
+						const branches = question.extraSettings?.branches || []
+						for (const branch of branches) {
+							for (const subQuestion of branch.subQuestions || []) {
+								subQuestions.set(subQuestion.id, {
+									conditionalId: question.id,
+									subQuestion,
+								})
+							}
+						}
+					}
+				}
+
+				for (const answer of loadedAnswers) {
+					const questionId = Number(answer.questionId)
+					const text = answer.text
+
+					logger.debug(`questionId: ${questionId}, answerId: ${answer.id}`)
+
+					// Answers of subquestions are part of the answer of their conditional question
+					const subQuestionEntry = subQuestions.get(questionId)
+					if (subQuestionEntry) {
+						const conditionalAnswer = getConditionalAnswer(
+							subQuestionEntry.conditionalId,
+						)
+						conditionalAnswer.subQuestions[questionId] = restoreAnswer(
+							subQuestionEntry.subQuestion,
+							text,
+							conditionalAnswer.subQuestions[questionId],
+						) as string[]
+						continue
+					}
+
+					// Clean up answers for questions that do not exist anymore
+					if (!validQuestionsIds.value.has(questionId)) {
+						showClearFormDueToChangeDialog.value = true
+						logger.debug('Question does not exist anymore', {
+							questionId,
+						})
+						continue
+					}
+
+					const question = props.form.questions.find(
+						(question: FormsQuestion) => question.id === questionId,
+					) as FormsQuestion | undefined
+					if (!question) {
+						continue
+					}
+
+					if (question.type === 'conditional') {
+						// The trigger is answered like a question of the trigger type
+						const conditionalAnswer = getConditionalAnswer(questionId)
+						conditionalAnswer.trigger = restoreAnswer(
+							{
+								...question,
+								type: question.extraSettings?.triggerType ?? '',
+							},
+							text,
+							conditionalAnswer.trigger,
+						) as string[]
+						continue
+					}
+
+					loaded[questionId] = restoreAnswer(
+						question,
+						text,
+						loaded[questionId],
+					)
 				}
 
 				answers.value = loaded
@@ -889,7 +982,7 @@ export default defineComponent({
 		 * @param question The question to answer
 		 * @param values The new values
 		 */
-		function onUpdate(question: SubmitQuestion, values: AnswerValue): void {
+		function onUpdate(question: FormsQuestion, values: AnswerValue): void {
 			answers.value = {
 				...answers.value,
 				[question.id]: values,
@@ -904,7 +997,7 @@ export default defineComponent({
 		 * @param values The updated question values.
 		 */
 		function updateQuestionValues(
-			question: SubmitQuestion,
+			question: FormsQuestion,
 			values: AnswerValue,
 		): void {
 			onUpdate(question, values)
diff --git a/tests/Integration/Api/ApiV3Test.php b/tests/Integration/Api/ApiV3Test.php
index 08ee397554..4eea5fecd4 100644
--- a/tests/Integration/Api/ApiV3Test.php
+++ b/tests/Integration/Api/ApiV3Test.php
@@ -63,7 +63,9 @@ private function setTestForms() {
 						'order' => 1,
 						'options' => [],
 						'accept' => [],
-						'extraSettings' => []
+						'extraSettings' => [],
+						'parentQuestionId' => null,
+						'branchId' => null,
 					],
 					[
 						'type' => 'multiple_unique',
@@ -89,7 +91,9 @@ private function setTestForms() {
 						'accept' => [],
 						'extraSettings' => [
 							'shuffleOptions' => true
-						]
+						],
+						'parentQuestionId' => null,
+						'branchId' => null,
 					],
 					[
 						'type' => 'file',
@@ -105,6 +109,8 @@ private function setTestForms() {
 							'maxAllowedFilesCount' => 1,
 							'maxFileSize' => 1024,
 						],
+						'parentQuestionId' => null,
+						'branchId' => null,
 					],
 				],
 				'shares' => [
@@ -190,7 +196,9 @@ private function setTestForms() {
 						'order' => 1,
 						'options' => [],
 						'accept' => [],
-						'extraSettings' => []
+						'extraSettings' => [],
+						'parentQuestionId' => null,
+						'branchId' => null,
 					],
 				],
 				'shares' => [
@@ -243,7 +251,9 @@ private function setTestForms() {
 						'order' => 1,
 						'options' => [],
 						'accept' => [],
-						'extraSettings' => []
+						'extraSettings' => [],
+						'parentQuestionId' => null,
+						'branchId' => null,
 					],
 				],
 				'shares' => [
@@ -496,7 +506,9 @@ public static function dataGetFullForm() {
 							'options' => [],
 							'accept' => [],
 							'description' => 'Please answer this.',
-							'extraSettings' => []
+							'extraSettings' => [],
+							'parentQuestionId' => null,
+							'branchId' => null,
 						],
 						[
 							'type' => 'multiple_unique',
@@ -525,7 +537,9 @@ public static function dataGetFullForm() {
 							'description' => '',
 							'extraSettings' => [
 								'shuffleOptions' => true,
-							]
+							],
+							'parentQuestionId' => null,
+							'branchId' => null,
 						],
 						[
 							'type' => 'file',
@@ -541,6 +555,8 @@ public static function dataGetFullForm() {
 								'maxAllowedFilesCount' => 1,
 								'maxFileSize' => 1024,
 							],
+							'parentQuestionId' => null,
+							'branchId' => null,
 						],
 					],
 					'shares' => [
@@ -851,6 +867,8 @@ public static function dataCreateNewQuestion() {
 					'accept' => [],
 					'description' => '',
 					'extraSettings' => [],
+					'parentQuestionId' => null,
+					'branchId' => null,
 				]
 			],
 			'emptyQuestion' => [
@@ -865,6 +883,8 @@ public static function dataCreateNewQuestion() {
 					'accept' => [],
 					'description' => '',
 					'extraSettings' => [],
+					'parentQuestionId' => null,
+					'branchId' => null,
 				]
 			]
 		];
@@ -1049,6 +1069,184 @@ public function testCloneQuestion() {
 		}
 	}
 
+	/**
+	 * Test creating a conditional question with trigger options
+	 */
+	public function testCreateConditionalQuestion(): void {
+		// First create the conditional question
+		$resp = $this->http->request('POST', "api/v3/forms/{$this->testForms[0]['id']}/questions", [
+			'json' => [
+				'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'text' => 'Conditional Question'
+			]
+		]);
+		$conditionalQuestion = $this->OcsResponse2Data($resp);
+		$this->testForms[0]['questions'][] = $conditionalQuestion;
+
+		$this->assertEquals(201, $resp->getStatusCode());
+		$this->assertEquals(Constants::ANSWER_TYPE_CONDITIONAL, $conditionalQuestion['type']);
+		$this->assertEquals('Conditional Question', $conditionalQuestion['text']);
+		$this->assertNull($conditionalQuestion['parentQuestionId']);
+		$this->assertNull($conditionalQuestion['branchId']);
+
+		// Add options for the trigger
+		$resp = $this->http->request('POST', "api/v3/forms/{$this->testForms[0]['id']}/questions/{$conditionalQuestion['id']}/options", [
+			'json' => [
+				'optionTexts' => ['Option A', 'Option B']
+			]
+		]);
+		$options = $this->OcsResponse2Data($resp);
+		$this->assertEquals(201, $resp->getStatusCode());
+		$this->assertCount(2, $options);
+
+		// Update the conditional question with extraSettings
+		$resp = $this->http->request('PATCH', "api/v3/forms/{$this->testForms[0]['id']}/questions/{$conditionalQuestion['id']}", [
+			'json' => [
+				'keyValuePairs' => [
+					'extraSettings' => [
+						'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+						'branches' => [
+							[
+								'id' => 'branch-a',
+								'conditions' => [['type' => 'option_selected', 'optionId' => $options[0]['id']]]
+							],
+							[
+								'id' => 'branch-b',
+								'conditions' => [['type' => 'option_selected', 'optionId' => $options[1]['id']]]
+							]
+						]
+					]
+				]
+			]
+		]);
+		$this->assertEquals(200, $resp->getStatusCode());
+
+		// Now create a subquestion in branch-a
+		$resp = $this->http->request('POST', "api/v3/forms/{$this->testForms[0]['id']}/questions", [
+			'json' => [
+				'type' => 'short',
+				'text' => 'Subquestion for Option A',
+				'parentQuestionId' => $conditionalQuestion['id'],
+				'branchId' => 'branch-a'
+			]
+		]);
+		$subQuestion = $this->OcsResponse2Data($resp);
+		$this->testForms[0]['questions'][] = $subQuestion;
+
+		$this->assertEquals(201, $resp->getStatusCode());
+		$this->assertEquals('short', $subQuestion['type']);
+		$this->assertEquals('Subquestion for Option A', $subQuestion['text']);
+		$this->assertEquals($conditionalQuestion['id'], $subQuestion['parentQuestionId']);
+		$this->assertEquals('branch-a', $subQuestion['branchId']);
+
+		// Fetch the form and verify the conditional question structure
+		$resp = $this->http->request('GET', "api/v3/forms/{$this->testForms[0]['id']}");
+		$form = $this->OcsResponse2Data($resp);
+		$this->assertEquals(200, $resp->getStatusCode());
+
+		// Find the conditional question in the form
+		$foundConditional = null;
+		foreach ($form['questions'] as $question) {
+			if ($question['id'] === $conditionalQuestion['id']) {
+				$foundConditional = $question;
+				break;
+			}
+		}
+
+		$this->assertNotNull($foundConditional);
+		$this->assertEquals(Constants::ANSWER_TYPE_CONDITIONAL, $foundConditional['type']);
+		$this->assertArrayHasKey('extraSettings', $foundConditional);
+		$this->assertArrayHasKey('branches', $foundConditional['extraSettings']);
+
+		// Verify subquestion is attached to the correct branch
+		$branchA = null;
+		foreach ($foundConditional['extraSettings']['branches'] as $branch) {
+			if ($branch['id'] === 'branch-a') {
+				$branchA = $branch;
+				break;
+			}
+		}
+
+		$this->assertNotNull($branchA);
+		$this->assertArrayHasKey('subQuestions', $branchA);
+		$this->assertCount(1, $branchA['subQuestions']);
+		$this->assertEquals('Subquestion for Option A', $branchA['subQuestions'][0]['text']);
+	}
+
+	/**
+	 * Test that nested conditional questions are not allowed
+	 */
+	public function testNestedConditionalNotAllowed(): void {
+		// First create a conditional question
+		$resp = $this->http->request('POST', "api/v3/forms/{$this->testForms[0]['id']}/questions", [
+			'json' => [
+				'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'text' => 'Parent Conditional'
+			]
+		]);
+		$parentConditional = $this->OcsResponse2Data($resp);
+		$this->testForms[0]['questions'][] = $parentConditional;
+		$this->assertEquals(201, $resp->getStatusCode());
+
+		// Add an option for the trigger
+		$resp = $this->http->request('POST', "api/v3/forms/{$this->testForms[0]['id']}/questions/{$parentConditional['id']}/options", [
+			'json' => [
+				'optionTexts' => ['Trigger Option']
+			]
+		]);
+		$options = $this->OcsResponse2Data($resp);
+
+		// Update with extraSettings
+		$resp = $this->http->request('PATCH', "api/v3/forms/{$this->testForms[0]['id']}/questions/{$parentConditional['id']}", [
+			'json' => [
+				'keyValuePairs' => [
+					'extraSettings' => [
+						'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+						'branches' => [
+							['id' => 'branch-1', 'conditions' => [['type' => 'option_selected', 'optionId' => $options[0]['id']]]]
+						]
+					]
+				]
+			]
+		]);
+
+		// Try to create a nested conditional (should fail)
+		$this->expectException(ClientException::class);
+		$this->http->request('POST', "api/v3/forms/{$this->testForms[0]['id']}/questions", [
+			'json' => [
+				'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'text' => 'Nested Conditional',
+				'parentQuestionId' => $parentConditional['id'],
+				'branchId' => 'branch-1'
+			]
+		]);
+	}
+
+	/**
+	 * Test that subquestion requires branchId
+	 */
+	public function testSubquestionRequiresBranchId(): void {
+		// First create a conditional question
+		$resp = $this->http->request('POST', "api/v3/forms/{$this->testForms[0]['id']}/questions", [
+			'json' => [
+				'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'text' => 'Conditional for branch test'
+			]
+		]);
+		$conditionalQuestion = $this->OcsResponse2Data($resp);
+		$this->testForms[0]['questions'][] = $conditionalQuestion;
+
+		// Try to create a subquestion without branchId (should fail)
+		$this->expectException(ClientException::class);
+		$this->http->request('POST', "api/v3/forms/{$this->testForms[0]['id']}/questions", [
+			'json' => [
+				'type' => 'short',
+				'text' => 'Subquestion without branch',
+				'parentQuestionId' => $conditionalQuestion['id']
+			]
+		]);
+	}
+
 	public static function dataCreateNewOption() {
 		return [
 			'newOption' => [
diff --git a/tests/Integration/DB/QuestionMapperTest.php b/tests/Integration/DB/QuestionMapperTest.php
new file mode 100644
index 0000000000..4b412082e5
--- /dev/null
+++ b/tests/Integration/DB/QuestionMapperTest.php
@@ -0,0 +1,142 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Forms\Tests\Integration\DB;
+
+use OCA\Forms\Constants;
+use OCA\Forms\Db\Option;
+use OCA\Forms\Db\OptionMapper;
+use OCA\Forms\Db\Question;
+use OCA\Forms\Db\QuestionMapper;
+use OCA\Forms\Tests\Integration\IntegrationBase;
+
+/**
+ * @group DB
+ */
+class QuestionMapperTest extends IntegrationBase {
+	private QuestionMapper $questionMapper;
+	/** @var array<string, Question> */
+	private array $questions = [];
+
+	protected array $users = [
+		'test' => 'Test user',
+	];
+
+	protected array $testForms = [
+		[
+			'hash' => 'question_mapper_form',
+			'title' => 'Question mapper form',
+			'description' => '',
+			'owner_id' => 'test',
+			'access_enum' => 0,
+			'created' => 12345,
+			'expires' => 0,
+			'state' => 0,
+			'is_anonymous' => false,
+			'submit_multiple' => false,
+			'show_expiration' => false,
+			'last_updated' => 123456789,
+			'submission_message' => '',
+			'file_id' => null,
+			'file_format' => null,
+			'questions' => [],
+			'shares' => [],
+		],
+	];
+
+	public function setUp(): void {
+		parent::setUp();
+		$this->questionMapper = \OCP\Server::get(QuestionMapper::class);
+
+		$formId = $this->testForms[0]['id'];
+		$this->questions['parent'] = $this->insertQuestion($formId, Constants::ANSWER_TYPE_CONDITIONAL, 1);
+		$this->questions['deletedTop'] = $this->insertQuestion($formId, Constants::ANSWER_TYPE_SHORT, 0);
+		$parentId = $this->questions['parent']->getId();
+		$this->questions['a2'] = $this->insertQuestion($formId, Constants::ANSWER_TYPE_SHORT, 2, $parentId, 'branch-a');
+		$this->questions['a1'] = $this->insertQuestion($formId, Constants::ANSWER_TYPE_SHORT, 1, $parentId, 'branch-a');
+		$this->questions['aDeleted'] = $this->insertQuestion($formId, Constants::ANSWER_TYPE_SHORT, 0, $parentId, 'branch-a');
+		$this->questions['b1'] = $this->insertQuestion($formId, Constants::ANSWER_TYPE_SHORT, 1, $parentId, 'branch-b');
+	}
+
+	public function tearDown(): void {
+		foreach ($this->questions as $question) {
+			$this->questionMapper->delete($question);
+		}
+		parent::tearDown();
+	}
+
+	private function insertQuestion(int $formId, string $type, int $order, ?int $parentQuestionId = null, ?string $branchId = null): Question {
+		$question = new Question();
+		$question->setFormId($formId);
+		$question->setType($type);
+		$question->setOrder($order);
+		$question->setText('Question');
+		$question->setDescription('');
+		$question->setName('');
+		$question->setIsRequired(false);
+		$question->setExtraSettings([]);
+		$question->setParentQuestionId($parentQuestionId);
+		$question->setBranchId($branchId);
+		return $this->questionMapper->insert($question);
+	}
+
+	/**
+	 * @param Question[] $questions
+	 * @return list<int>
+	 */
+	private function ids(array $questions): array {
+		return array_map(static fn (Question $question) => $question->getId(), $questions);
+	}
+
+	private function id(string $key): int {
+		return $this->questions[$key]->getId();
+	}
+
+	public function testFindByFormSkipsSubquestions(): void {
+		$questions = $this->questionMapper->findByForm($this->testForms[0]['id']);
+		$this->assertSame([$this->id('parent')], $this->ids($questions));
+	}
+
+	public function testFindByFormWithSubquestionsAndDeleted(): void {
+		$questions = $this->questionMapper->findByForm($this->testForms[0]['id'], true, true);
+		$this->assertEqualsCanonicalizing(
+			[$this->id('parent'), $this->id('deletedTop'), $this->id('a2'), $this->id('a1'), $this->id('aDeleted'), $this->id('b1')],
+			$this->ids($questions),
+		);
+	}
+
+	public function testFindByParentQuestion(): void {
+		$questions = $this->questionMapper->findByParentQuestion($this->id('parent'));
+		$this->assertEqualsCanonicalizing([$this->id('a1'), $this->id('a2'), $this->id('b1')], $this->ids($questions));
+
+		$withDeleted = $this->questionMapper->findByParentQuestion($this->id('parent'), true);
+		$this->assertContains($this->id('aDeleted'), $this->ids($withDeleted));
+	}
+
+	public function testFindByBranchIsOrdered(): void {
+		$questions = $this->questionMapper->findByBranch($this->id('parent'), 'branch-a');
+		$this->assertSame([$this->id('a1'), $this->id('a2')], $this->ids($questions));
+	}
+
+	public function testDeleteByFormDeletesOptionsOfSubquestions(): void {
+		$optionMapper = \OCP\Server::get(OptionMapper::class);
+		$option = new Option();
+		$option->setQuestionId($this->id('b1'));
+		$option->setText('Option of a subquestion');
+		$option->setOrder(1);
+		$optionMapper->insert($option);
+		$subQuestionId = $this->id('b1');
+
+		$this->questionMapper->deleteByForm($this->testForms[0]['id']);
+		// Nothing left to clean up
+		$this->questions = [];
+
+		$this->assertSame([], $optionMapper->findByQuestion($subQuestionId));
+	}
+}
diff --git a/tests/Integration/DB/SubmissionMapperTest.php b/tests/Integration/DB/SubmissionMapperTest.php
index 7f76fa218f..f3b7ee013a 100644
--- a/tests/Integration/DB/SubmissionMapperTest.php
+++ b/tests/Integration/DB/SubmissionMapperTest.php
@@ -54,7 +54,9 @@ private function setTestForms() {
 						'options' => [],
 						'accept' => [],
 						'description' => 'Please answer this.',
-						'extraSettings' => []
+						'extraSettings' => [],
+						'parentQuestionId' => null,
+						'branchId' => null,
 					]
 				],
 				'shares' => [],
diff --git a/tests/Unit/Analytics/AnalyticsDatasourceTest.php b/tests/Unit/Analytics/AnalyticsDatasourceTest.php
index c01330a684..faf08fa56f 100644
--- a/tests/Unit/Analytics/AnalyticsDatasourceTest.php
+++ b/tests/Unit/Analytics/AnalyticsDatasourceTest.php
@@ -86,7 +86,9 @@ public function testReadData() {
 		// Mock questions
 		$questions = [
 			['id' => 1, 'text' => 'Question 1'],
-			['id' => 2, 'text' => 'Question 2']
+			['id' => 2, 'text' => 'Question 2', 'extraSettings' => ['branches' => [
+				['id' => 'branch-1', 'subQuestions' => [['id' => 3, 'text' => 'Question 2.1']]],
+			]]],
 		];
 		$this->formsService->method('getQuestions')->willReturn($questions);
 
@@ -97,7 +99,8 @@ public function testReadData() {
 				['questionId' => 2, 'text' => 'Answer 2']
 			]],
 			['answers' => [
-				['questionId' => 1, 'text' => 'Answer 1']
+				['questionId' => 1, 'text' => 'Answer 1'],
+				['questionId' => 3, 'text' => 'Answer 3']
 			]]
 		];
 		$this->submissionService->method('getSubmissions')->willReturn($submissions);
@@ -116,7 +119,8 @@ public function testReadData() {
 			'dimensions' => ['Question', 'Answer'],
 			'data' => [
 				['Question 1', 'Answer 1', 2],
-				['Question 2', 'Answer 2', 1]
+				['Question 2', 'Answer 2', 1],
+				['Question 2.1', 'Answer 3', 1]
 			],
 			'error' => 0
 		];
diff --git a/tests/Unit/Controller/ApiControllerTest.php b/tests/Unit/Controller/ApiControllerTest.php
index 281fdb53e1..b6bae11746 100644
--- a/tests/Unit/Controller/ApiControllerTest.php
+++ b/tests/Unit/Controller/ApiControllerTest.php
@@ -34,6 +34,7 @@ function is_uploaded_file(string|bool|null $filename) {
 use OCA\Forms\BackgroundJob\SyncSubmissionsWithLinkedFileJob;
 use OCA\Forms\Constants;
 use OCA\Forms\Controller\ApiController;
+use OCA\Forms\Db\Answer;
 use OCA\Forms\Db\AnswerMapper;
 use OCA\Forms\Db\Form;
 use OCA\Forms\Db\FormMapper;
@@ -103,6 +104,8 @@ class ApiControllerTest extends TestCase {
 	private array $dispatchedEvents = [];
 
 	public function setUp(): void {
+		parent::setUp();
+
 		$this->answerMapper = $this->createMock(AnswerMapper::class);
 		$this->formMapper = $this->createMock(FormMapper::class);
 		$this->optionMapper = $this->createMock(OptionMapper::class);
@@ -282,7 +285,32 @@ public static function dataGetSubmissions() {
 					],
 					'filteredSubmissionsCount' => 1,
 				]
-			]
+			],
+			'subquestion' => [
+				'submissions' => [
+					['userId' => 'jdoe', 'answers' => [['questionId' => 2, 'text' => 'Rex']]]
+				],
+				'questions' => [[
+					'id' => 1,
+					'name' => '',
+					'extraSettings' => ['branches' => [['id' => 'branch-1', 'subQuestions' => [['id' => 2, 'name' => 'pet']]]]],
+				]],
+				'expected' => [
+					'submissions' => [
+						[
+							'userId' => 'jdoe',
+							'answers' => [['questionId' => 2, 'text' => 'Rex', 'questionName' => 'pet']],
+							'userDisplayName' => 'jdoe',
+						]
+					],
+					'questions' => [[
+						'id' => 1,
+						'name' => '',
+						'extraSettings' => ['branches' => [['id' => 'branch-1', 'subQuestions' => [['id' => 2, 'name' => 'pet']]]]],
+					]],
+					'filteredSubmissionsCount' => 1,
+				]
+			],
 		];
 	}
 
@@ -900,7 +928,7 @@ public function testNewSubmission_answers() {
 
 		$this->answerMapper->expects($this->exactly(5))
 			->method('insert')
-			->with($this->callback(function ($answer) {
+			->with($this->callback(function (Answer $answer) {
 				if ($answer->getSubmissionId() !== 12) {
 					return false;
 				}
@@ -921,6 +949,11 @@ public function testNewSubmission_answers() {
 							return false;
 						}
 						break;
+					case 4:
+						if ($answer->getFileId() !== 100 || $answer->getText() !== 'uploaded-file.txt') {
+							return false;
+						}
+						break;
 				}
 
 				return true;
@@ -939,6 +972,12 @@ public function testNewSubmission_answers() {
 			->willReturn(true);
 
 		$file = $this->createMock(File::class);
+		$file->expects($this->once())
+			->method('getName')
+			->willReturn('uploaded-file.txt');
+		$file->expects($this->once())
+			->method('move')
+			->with('/admin/files/submission-12/uploaded-file.txt');
 
 		$uploadedFile = new UploadedFile();
 		$uploadedFile->setFileId(100);
@@ -949,9 +988,17 @@ public function testNewSubmission_answers() {
 
 		$userFolder->expects($this->once())
 			->method('getById')
+			->with(100)
 			->willReturn([$file]);
 
 		$folder = $this->createMock(Folder::class);
+		$folder->expects($this->once())
+			->method('getNonExistingName')
+			->with('uploaded-file.txt')
+			->willReturn('uploaded-file.txt');
+		$folder->expects($this->once())
+			->method('getPath')
+			->willReturn('/admin/files/submission-12');
 
 		$userFolder->expects($this->once())
 			->method('get')
@@ -965,6 +1012,311 @@ public function testNewSubmission_answers() {
 		$this->apiController->newSubmission(1, $answers, '');
 	}
 
+	public static function dataNewSubmission_fileUploadAuthorization(): array {
+		return [
+			'ordinary valid token' => [false, 'valid-upload-token', true],
+			'ordinary foreign token' => [false, 'foreign-upload-token', false],
+			'ordinary missing token' => [false, null, false],
+			'ordinary empty token' => [false, '', false],
+			'conditional valid token' => [true, 'valid-upload-token', true],
+			'conditional foreign token' => [true, 'foreign-upload-token', false],
+			'conditional missing token' => [true, null, false],
+			'conditional empty token' => [true, '', false],
+		];
+	}
+
+	/**
+	 * @dataProvider dataNewSubmission_fileUploadAuthorization
+	 */
+	public function testNewSubmission_fileUploadAuthorization(bool $conditional, ?string $uploadToken, bool $authorized): void {
+		$form = Form::fromParams(['id' => 7, 'hash' => 'hash', 'ownerId' => 'admin']);
+		$fileQuestion = [
+			'id' => 8,
+			'formId' => 7,
+			'name' => null,
+			'text' => 'File question',
+			'type' => Constants::ANSWER_TYPE_FILE,
+			'options' => [],
+			'extraSettings' => ['maxAllowedFilesCount' => 1],
+		];
+		$branch = [
+			'id' => 'file-branch',
+			'conditions' => [['type' => 'option_selected', 'optionId' => 3]],
+			'subQuestions' => [$fileQuestion],
+		];
+		$question = $conditional ? [
+			'id' => 9,
+			'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+			'text' => 'Conditional question',
+			'options' => [['id' => 3, 'text' => 'Attach a file']],
+			'extraSettings' => [
+				'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+				'branches' => [$branch],
+			],
+		] : $fileQuestion;
+		$fileAnswer = ['uploadedFileId' => '10', 'fileName' => 'client-supplied.txt'];
+		if ($uploadToken !== null) {
+			$fileAnswer['uploadToken'] = $uploadToken;
+		}
+		$answers = $conditional
+			? [9 => ['trigger' => ['3'], 'subQuestions' => [8 => [$fileAnswer]]]]
+			: [8 => [$fileAnswer]];
+
+		$this->formsService->expects($this->once())
+			->method('loadFormForSubmission')
+			->with(7, '')
+			->willReturn($form);
+		$this->formsService->expects($this->once())
+			->method('getQuestions')
+			->with(7)
+			->willReturn([$question]);
+		$this->formAccess();
+
+		// Validation succeeds so storage must independently authorize the upload.
+		$this->submissionService->expects($this->once())
+			->method('validateSubmission')
+			->with([$question], $answers, 'admin', 7);
+		$this->submissionService->expects($conditional ? $this->once() : $this->never())
+			->method('getActiveBranches')
+			->with($question, ['3'])
+			->willReturn([$branch]);
+		$this->submissionMapper->expects($this->once())
+			->method('insert')
+			->willReturnCallback(function (Submission $submission): Submission {
+				$this->assertSame(7, $submission->getFormId());
+				$submission->setId(12);
+				return $submission;
+			});
+
+		$expectedAnswers = $conditional ? [[9, 12, null, 'Attach a file']] : [];
+		if ($authorized) {
+			$expectedAnswers[] = [8, 12, 99, 'real-file.txt'];
+		}
+		$this->answerMapper->expects($this->exactly(count($expectedAnswers)))
+			->method('insert')
+			->willReturnCallback(function (Answer $answer) use (&$expectedAnswers): Answer {
+				$this->assertSame(array_shift($expectedAnswers), [
+					$answer->getQuestionId(),
+					$answer->getSubmissionId(),
+					$answer->getFileId(),
+					$answer->getText(),
+				]);
+				return $answer;
+			});
+
+		$uploadedFile = UploadedFile::fromParams([
+			'id' => 10,
+			'formId' => 7,
+			'questionId' => 8,
+			'uploadToken' => 'valid-upload-token',
+			'fileId' => 99,
+		]);
+		$lookup = $this->uploadedFileMapper->expects($this->once())
+			->method('getForSubmission')
+			->with($this->identicalTo(10), 7, 8, $uploadToken ?? '');
+		$this->uploadedFileMapper->expects($this->never())->method('getByUploadedFileId');
+		$this->uploadedFileMapper->expects($this->never())->method('findByUploadedFileId');
+		$this->uploadedFileMapper->expects($authorized ? $this->once() : $this->never())
+			->method('delete')
+			->with($uploadedFile);
+
+		$file = $this->createMock(File::class);
+		$file->expects($authorized ? $this->once() : $this->never())
+			->method('getName')
+			->willReturn('real-file.txt');
+		$file->expects($authorized ? $this->once() : $this->never())
+			->method('move')
+			->with('/admin/files/Forms/submission-12/question-8/real-file.txt');
+		$folder = $this->createMock(Folder::class);
+		$folder->expects($authorized ? $this->once() : $this->never())
+			->method('getNonExistingName')
+			->with('real-file.txt')
+			->willReturn('real-file.txt');
+		$folder->expects($authorized ? $this->once() : $this->never())
+			->method('getPath')
+			->willReturn('/admin/files/Forms/submission-12/question-8');
+		$userFolder = $this->createMock(Folder::class);
+		$userFolder->expects($authorized ? $this->once() : $this->never())
+			->method('nodeExists')
+			->with('Forms/submission-12/question-8')
+			->willReturn(true);
+		$userFolder->expects($authorized ? $this->once() : $this->never())
+			->method('get')
+			->with('Forms/submission-12/question-8')
+			->willReturn($folder);
+		$userFolder->expects($authorized ? $this->once() : $this->never())
+			->method('getById')
+			->with(99)
+			->willReturn([$file]);
+		$this->storage->expects($authorized ? $this->once() : $this->never())
+			->method('getUserFolder')
+			->with('admin')
+			->willReturn($userFolder);
+		$this->formsService->expects($authorized ? $this->once() : $this->never())
+			->method('getUploadedFilePath')
+			->with($form, 12, 8, null, 'File question')
+			->willReturn('Forms/submission-12/question-8');
+		$this->formsService->expects($authorized ? $this->once() : $this->never())
+			->method('notifyNewSubmission');
+
+		if ($authorized) {
+			$lookup->willReturn($uploadedFile);
+		} else {
+			$lookup->willThrowException(new DoesNotExistException('Upload authorization failed'));
+			$this->expectException(DoesNotExistException::class);
+			$this->expectExceptionMessage('Upload authorization failed');
+		}
+
+		$this->assertEquals(new DataResponse(null, Http::STATUS_CREATED), $this->apiController->newSubmission(7, $answers, ''));
+	}
+
+	public function testNewSubmission_conditionalQuestion() {
+		$form = new Form();
+		$form->setId(1);
+		$form->setHash('hash');
+		$form->setOwnerId('admin');
+
+		$questions = [
+			[
+				'id' => 100,
+				'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'text' => 'Conditional Q',
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+					'branches' => [
+						[
+							'id' => 'branch-a',
+							'conditions' => [['type' => 'option_selected', 'optionId' => 10]],
+							'subQuestions' => [
+								[
+									'id' => 101,
+									'type' => 'short',
+									'text' => 'Sub Q',
+									'isRequired' => false,
+								]
+							]
+						]
+					]
+				],
+				'options' => [
+					['id' => 10, 'text' => 'Option A'],
+					['id' => 11, 'text' => 'Option B'],
+				],
+			],
+		];
+
+		$answers = [
+			100 => [
+				'trigger' => ['10'],
+				'subQuestions' => [
+					'101' => ['Sub answer']
+				]
+			],
+		];
+
+		$this->formsService->expects($this->once())
+			->method('loadFormForSubmission')
+			->with(1)
+			->willReturn($form);
+
+		$this->formsService->expects($this->once())
+			->method('getQuestions')
+			->with(1)
+			->willReturn($questions);
+
+		$this->formAccess();
+
+		$this->submissionMapper->expects($this->once())
+			->method('insert')
+			->with($this->callback(function ($submission) {
+				$submission->setId(12);
+				return true;
+			}));
+
+		$this->submissionService->expects($this->once())
+			->method('getActiveBranches')
+			->with($questions[0], $answers[100]['trigger'])
+			->willReturn([$questions[0]['extraSettings']['branches'][0]]);
+
+		// Trigger answer + subquestion answer = 2 inserts
+		$this->answerMapper->expects($this->exactly(2))
+			->method('insert');
+
+		$this->formsService->expects($this->once())
+			->method('notifyNewSubmission');
+
+		$this->apiController->newSubmission(1, $answers, '');
+	}
+
+	public function testNewSubmissionStoresSubquestionsLikeQuestions(): void {
+		$form = new Form();
+		$form->setId(1);
+		$form->setHash('hash');
+		$form->setOwnerId('admin');
+
+		$branch = [
+			'id' => 'branch-a',
+			'conditions' => [['optionId' => 10]],
+			'subQuestions' => [
+				[
+					'id' => 101,
+					'type' => Constants::ANSWER_TYPE_RANKING,
+					'text' => 'Rank',
+					'extraSettings' => [],
+					'options' => [['id' => 1, 'text' => 'R1'], ['id' => 2, 'text' => 'R2']],
+				],
+				[
+					'id' => 102,
+					'type' => Constants::ANSWER_TYPE_MULTIPLEUNIQUE,
+					'text' => 'Radio',
+					'extraSettings' => ['allowOtherAnswer' => true],
+					'options' => [['id' => 3, 'text' => 'Fixed']],
+				],
+			],
+		];
+		$question = [
+			'id' => 100,
+			'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+			'text' => 'Conditional Q',
+			'extraSettings' => [
+				'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+				'branches' => [$branch],
+			],
+			'options' => [['id' => 10, 'text' => 'Option A']],
+		];
+
+		$this->formsService->method('loadFormForSubmission')->willReturn($form);
+		$this->formsService->method('getQuestions')->willReturn([$question]);
+		$this->formAccess();
+		$this->submissionMapper->method('insert')->willReturnCallback(function ($submission) {
+			$submission->setId(12);
+			return $submission;
+		});
+		$this->submissionService->method('getActiveBranches')->willReturn([$branch]);
+
+		$stored = [];
+		$this->answerMapper->method('insert')->willReturnCallback(function (Answer $answer) use (&$stored) {
+			$stored[] = [$answer->getQuestionId(), $answer->getText()];
+			return $answer;
+		});
+
+		$this->apiController->newSubmission(1, [
+			100 => [
+				'trigger' => [10],
+				'subQuestions' => [
+					101 => ['2', '1'],
+					102 => [Constants::QUESTION_EXTRASETTINGS_OTHER_PREFIX . 'typed'],
+				],
+			],
+		], '');
+
+		$this->assertSame([
+			[100, 'Option A'],
+			[101, '["2","1"]'],
+			[102, 'typed'],
+		], $stored);
+	}
+
 	public function testNewSubmission_formNotFound() {
 		$this->formsService->expects($this->once())
 			->method('loadFormForSubmission')
@@ -1411,6 +1763,94 @@ public function testUpdateQuestionClearsConfirmationEmailQuestionIdWhenQuestionS
 		$this->assertNull($form->getConfirmationEmailQuestionId());
 	}
 
+	private function mockEditableForm(int $formId = 1): Form {
+		$form = new Form();
+		$form->setId($formId);
+		$form->setOwnerId('currentUser');
+
+		$this->formsService->method('getFormIfAllowed')
+			->with($formId, Constants::PERMISSION_EDIT)
+			->willReturn($form);
+		$this->formsService->method('isFormArchived')->willReturn(false);
+
+		return $form;
+	}
+
+	private function createConditionalQuestion(): Question {
+		$question = new Question();
+		$question->setId(100);
+		$question->setFormId(1);
+		$question->setOrder(1);
+		$question->setType(Constants::ANSWER_TYPE_CONDITIONAL);
+		$question->setExtraSettings([
+			'triggerType' => Constants::ANSWER_TYPE_MULTIPLEUNIQUE,
+			'branches' => [
+				['id' => 'branch-a', 'conditions' => [['optionId' => 10]]],
+				['id' => 'branch-b', 'conditions' => [['optionId' => 11]]],
+			],
+		]);
+		return $question;
+	}
+
+	private function createSubQuestion(int $id, string $branchId, int $order): Question {
+		$question = new Question();
+		$question->setId($id);
+		$question->setFormId(1);
+		$question->setOrder($order);
+		$question->setType(Constants::ANSWER_TYPE_SHORT);
+		$question->setParentQuestionId(100);
+		$question->setBranchId($branchId);
+		return $question;
+	}
+
+	public function testReorderQuestionsRejectsSubquestion(): void {
+		$this->mockEditableForm();
+		$this->questionMapper->method('findByForm')->with(1)->willReturn([$this->createConditionalQuestion()]);
+		$this->questionMapper->method('findById')->with(101)->willReturn($this->createSubQuestion(101, 'branch-a', 1));
+		$this->questionMapper->expects($this->never())->method('update');
+
+		$this->expectException(OCSBadRequestException::class);
+		$this->expectExceptionMessage('Subquestions can only be reordered within their branch');
+		$this->apiController->reorderQuestions(1, [101]);
+	}
+
+	public static function dataUpdateQuestionRejectsKeys(): array {
+		return [
+			'parentQuestionId' => [['parentQuestionId' => 200]],
+			'branchId' => [['branchId' => 'branch-x']],
+			'options' => [['options' => []]],
+			'accept' => [['accept' => []]],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataUpdateQuestionRejectsKeys')]
+	public function testUpdateQuestionRejectsKeys(array $keyValuePairs): void {
+		$this->mockEditableForm();
+		$this->questionMapper->method('findById')->with(101)->willReturn($this->createSubQuestion(101, 'branch-a', 1));
+		$this->questionMapper->expects($this->never())->method('update');
+
+		$this->expectException(OCSForbiddenException::class);
+		$this->apiController->updateQuestion(1, 101, $keyValuePairs);
+	}
+
+	public static function dataUpdateQuestionConditionalTypeChange(): array {
+		return [
+			'subquestion into conditional' => [false, Constants::ANSWER_TYPE_CONDITIONAL],
+			'conditional into short' => [true, Constants::ANSWER_TYPE_SHORT],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataUpdateQuestionConditionalTypeChange')]
+	public function testUpdateQuestionConditionalTypeChange(bool $isConditional, string $newType): void {
+		$this->mockEditableForm();
+		$question = $isConditional ? $this->createConditionalQuestion() : $this->createSubQuestion(101, 'branch-a', 1);
+		$this->questionMapper->method('findById')->willReturn($question);
+		$this->questionMapper->expects($this->never())->method('update');
+
+		$this->expectException(OCSBadRequestException::class);
+		$this->apiController->updateQuestion(1, $question->getId(), ['type' => $newType]);
+	}
+
 	public function testDeleteQuestionClearsConfirmationEmailQuestionIdWhenDeletingSelectedQuestion(): void {
 		$form = new Form();
 		$form->setId(1);
@@ -2760,4 +3200,558 @@ public function testUpdateSubmission_resultsDeleteShareCanEditOthers() {
 		$response = $this->apiController->updateSubmission($formId, $submissionId, $answers);
 		$this->assertEquals(new DataResponse($submissionId), $response);
 	}
+
+	// Tests for new conditional question functionality
+
+	public function testNewQuestion_conditionalQuestion() {
+		$formId = 1;
+		$form = new Form();
+		$form->setId($formId);
+
+		$this->formsService->expects($this->once())
+			->method('getFormIfAllowed')
+			->with($formId, Constants::PERMISSION_EDIT)
+			->willReturn($form);
+
+		$this->formsService->expects($this->once())
+			->method('obtainFormLock')
+			->with($form);
+
+		$this->questionMapper->expects($this->once())
+			->method('findByForm')
+			->with($formId)
+			->willReturn([]);
+
+		$this->questionMapper->expects($this->once())
+			->method('insert')
+			->willReturnCallback(function ($question) {
+				$question->setId(100);
+				return $question;
+			});
+
+		$this->formsService->expects($this->once())
+			->method('getQuestion')
+			->with(100)
+			->willReturn([
+				'id' => 100,
+				'formId' => $formId,
+				'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'text' => 'Conditional Q',
+				'order' => 1,
+				'isRequired' => false,
+				'name' => '',
+				'options' => [],
+				'accept' => [],
+				'description' => '',
+				'extraSettings' => [],
+				'parentQuestionId' => null,
+				'branchId' => null,
+			]);
+
+		$response = $this->apiController->newQuestion($formId, Constants::ANSWER_TYPE_CONDITIONAL, null, 'Conditional Q');
+		$this->assertInstanceOf(DataResponse::class, $response);
+		$this->assertEquals(Http::STATUS_CREATED, $response->getStatus());
+		$data = $response->getData();
+		$this->assertEquals(Constants::ANSWER_TYPE_CONDITIONAL, $data['type']);
+	}
+
+	public function testNewQuestion_subQuestion() {
+		$formId = 1;
+		$parentQuestionId = 100;
+		$branchId = 'branch-1';
+
+		$form = new Form();
+		$form->setId($formId);
+
+		$parentQuestion = new Question();
+		$parentQuestion->setId($parentQuestionId);
+		$parentQuestion->setFormId($formId);
+		$parentQuestion->setType(Constants::ANSWER_TYPE_CONDITIONAL);
+		$parentQuestion->setExtraSettings(['triggerType' => 'short', 'branches' => [['id' => $branchId, 'conditions' => []]]]);
+
+		$this->formsService->expects($this->once())
+			->method('getFormIfAllowed')
+			->with($formId, Constants::PERMISSION_EDIT)
+			->willReturn($form);
+
+		$this->formsService->expects($this->once())
+			->method('obtainFormLock')
+			->with($form);
+
+		$this->questionMapper->expects($this->once())
+			->method('findById')
+			->with($parentQuestionId)
+			->willReturn($parentQuestion);
+
+		$this->questionMapper->expects($this->once())
+			->method('findByBranch')
+			->with($parentQuestionId, $branchId)
+			->willReturn([]);
+
+		$this->questionMapper->expects($this->once())
+			->method('insert')
+			->willReturnCallback(function ($question) {
+				$question->setId(101);
+				return $question;
+			});
+
+		$this->formsService->expects($this->once())
+			->method('getQuestion')
+			->with(101)
+			->willReturn([
+				'id' => 101,
+				'formId' => $formId,
+				'type' => 'short',
+				'text' => 'Sub Q',
+				'order' => 1,
+				'isRequired' => false,
+				'name' => '',
+				'options' => [],
+				'accept' => [],
+				'description' => '',
+				'extraSettings' => [],
+				'parentQuestionId' => $parentQuestionId,
+				'branchId' => $branchId,
+			]);
+
+		$response = $this->apiController->newQuestion($formId, 'short', null, 'Sub Q', null, $parentQuestionId, $branchId);
+		$this->assertInstanceOf(DataResponse::class, $response);
+		$this->assertEquals(Http::STATUS_CREATED, $response->getStatus());
+		$data = $response->getData();
+		$this->assertEquals($parentQuestionId, $data['parentQuestionId']);
+		$this->assertEquals($branchId, $data['branchId']);
+	}
+
+	public function testNewQuestion_nestedConditionalNotAllowed() {
+		$formId = 1;
+		$parentQuestionId = 100;
+		$branchId = 'branch-1';
+
+		$form = new Form();
+		$form->setId($formId);
+
+		$this->formsService->expects($this->once())
+			->method('getFormIfAllowed')
+			->with($formId, Constants::PERMISSION_EDIT)
+			->willReturn($form);
+
+		$this->formsService->expects($this->once())
+			->method('obtainFormLock')
+			->with($form);
+
+		$this->expectException(OCSBadRequestException::class);
+		$this->expectExceptionMessage('Nested conditional questions are not supported');
+		$this->apiController->newQuestion($formId, Constants::ANSWER_TYPE_CONDITIONAL, null, 'Nested Conditional', null, $parentQuestionId, $branchId);
+	}
+
+	public function testNewQuestion_parentNotFound() {
+		$formId = 1;
+		$parentQuestionId = 999;
+		$branchId = 'branch-1';
+
+		$form = new Form();
+		$form->setId($formId);
+
+		$this->formsService->expects($this->once())
+			->method('getFormIfAllowed')
+			->with($formId, Constants::PERMISSION_EDIT)
+			->willReturn($form);
+
+		$this->formsService->expects($this->once())
+			->method('obtainFormLock')
+			->with($form);
+
+		$this->questionMapper->expects($this->once())
+			->method('findById')
+			->with($parentQuestionId)
+			->willThrowException(new DoesNotExistException('Question not found'));
+
+		$this->expectException(OCSNotFoundException::class);
+		$this->expectExceptionMessage('Could not find parent question');
+		$this->apiController->newQuestion($formId, 'short', null, 'Sub Q', null, $parentQuestionId, $branchId);
+	}
+
+	public function testNewQuestion_parentNotConditional() {
+		$formId = 1;
+		$parentQuestionId = 100;
+		$branchId = 'branch-1';
+
+		$form = new Form();
+		$form->setId($formId);
+
+		$parentQuestion = new Question();
+		$parentQuestion->setId($parentQuestionId);
+		$parentQuestion->setFormId($formId);
+		$parentQuestion->setType('short'); // Not conditional
+
+		$this->formsService->expects($this->once())
+			->method('getFormIfAllowed')
+			->with($formId, Constants::PERMISSION_EDIT)
+			->willReturn($form);
+
+		$this->formsService->expects($this->once())
+			->method('obtainFormLock')
+			->with($form);
+
+		$this->questionMapper->expects($this->once())
+			->method('findById')
+			->with($parentQuestionId)
+			->willReturn($parentQuestion);
+
+		$this->expectException(OCSBadRequestException::class);
+		$this->expectExceptionMessage('Parent question must be a conditional question');
+		$this->apiController->newQuestion($formId, 'short', null, 'Sub Q', null, $parentQuestionId, $branchId);
+	}
+
+	public function testNewQuestion_parentDifferentForm() {
+		$formId = 1;
+		$parentQuestionId = 100;
+		$branchId = 'branch-1';
+
+		$form = new Form();
+		$form->setId($formId);
+
+		$parentQuestion = new Question();
+		$parentQuestion->setId($parentQuestionId);
+		$parentQuestion->setFormId(999); // Different form
+		$parentQuestion->setType(Constants::ANSWER_TYPE_CONDITIONAL);
+
+		$this->formsService->expects($this->once())
+			->method('getFormIfAllowed')
+			->with($formId, Constants::PERMISSION_EDIT)
+			->willReturn($form);
+
+		$this->formsService->expects($this->once())
+			->method('obtainFormLock')
+			->with($form);
+
+		$this->questionMapper->expects($this->once())
+			->method('findById')
+			->with($parentQuestionId)
+			->willReturn($parentQuestion);
+
+		$this->expectException(OCSBadRequestException::class);
+		$this->expectExceptionMessage('Parent question does not belong to this form');
+		$this->apiController->newQuestion($formId, 'short', null, 'Sub Q', null, $parentQuestionId, $branchId);
+	}
+
+	public function testNewQuestion_parentOfOtherFormIsNotDescribed() {
+		$form = new Form();
+		$form->setId(1);
+
+		// The type of a question of another form is not told
+		$parentQuestion = new Question();
+		$parentQuestion->setId(100);
+		$parentQuestion->setFormId(999);
+		$parentQuestion->setType('short');
+
+		$this->formsService->method('getFormIfAllowed')->willReturn($form);
+		$this->questionMapper->method('findById')->with(100)->willReturn($parentQuestion);
+
+		$this->expectException(OCSBadRequestException::class);
+		$this->expectExceptionMessage('Parent question does not belong to this form');
+		$this->apiController->newQuestion(1, 'short', null, 'Sub Q', null, 100, 'branch-1');
+	}
+
+	public function testNewQuestion_missingBranchId() {
+		$formId = 1;
+		$parentQuestionId = 100;
+
+		$form = new Form();
+		$form->setId($formId);
+
+		$parentQuestion = new Question();
+		$parentQuestion->setId($parentQuestionId);
+		$parentQuestion->setFormId($formId);
+		$parentQuestion->setType(Constants::ANSWER_TYPE_CONDITIONAL);
+
+		$this->formsService->expects($this->once())
+			->method('getFormIfAllowed')
+			->with($formId, Constants::PERMISSION_EDIT)
+			->willReturn($form);
+
+		$this->formsService->expects($this->once())
+			->method('obtainFormLock')
+			->with($form);
+
+		$this->questionMapper->expects($this->once())
+			->method('findById')
+			->with($parentQuestionId)
+			->willReturn($parentQuestion);
+
+		$this->expectException(OCSBadRequestException::class);
+		$this->expectExceptionMessage('branchId is required when creating a subquestion');
+		$this->apiController->newQuestion($formId, 'short', null, 'Sub Q', null, $parentQuestionId, null);
+	}
+
+	public function testDeleteQuestion_conditionalWithSubquestions(): void {
+		$formId = 1;
+		$questionId = 100;
+
+		$form = new Form();
+		$form->setId($formId);
+
+		$question = new Question();
+		$question->setId($questionId);
+		$question->setFormId($formId);
+		$question->setType(Constants::ANSWER_TYPE_CONDITIONAL);
+		$question->setOrder(1);
+
+		$subQuestion1 = new Question();
+		$subQuestion1->setId(101);
+		$subQuestion1->setFormId($formId);
+		$subQuestion1->setType('short');
+		$subQuestion1->setOrder(1);
+		$subQuestion1->setParentQuestionId($questionId);
+
+		$subQuestion2 = new Question();
+		$subQuestion2->setId(102);
+		$subQuestion2->setFormId($formId);
+		$subQuestion2->setType('long');
+		$subQuestion2->setOrder(2);
+		$subQuestion2->setParentQuestionId($questionId);
+
+		$this->formsService->expects($this->once())
+			->method('getFormIfAllowed')
+			->with($formId, Constants::PERMISSION_EDIT)
+			->willReturn($form);
+
+		$this->formsService->expects($this->once())
+			->method('obtainFormLock')
+			->with($form);
+
+		$this->formsService->expects($this->once())
+			->method('isFormArchived')
+			->with($form)
+			->willReturn(false);
+
+		$this->questionMapper->expects($this->once())
+			->method('findById')
+			->with($questionId)
+			->willReturn($question);
+
+		$this->questionMapper->expects($this->once())
+			->method('findByParentQuestion')
+			->with($questionId)
+			->willReturn([$subQuestion1, $subQuestion2]);
+
+		$this->questionMapper->expects($this->once())
+			->method('findByForm')
+			->with($formId)
+			->willReturn([]);
+
+		// Expect updates for: subQuestion1, subQuestion2, main question
+		$this->questionMapper->expects($this->exactly(3))
+			->method('update');
+
+		$this->formMapper->expects($this->once())
+			->method('update')
+			->with($form);
+
+		$response = $this->apiController->deleteQuestion($formId, $questionId);
+		$this->assertInstanceOf(DataResponse::class, $response);
+		$this->assertEquals($questionId, $response->getData());
+	}
+
+	public function testUpdateQuestionRemovedBranchDeletesSubquestions(): void {
+		$this->mockEditableForm();
+		$this->formsService->method('areExtraSettingsValid')->willReturn(true);
+		$this->questionMapper->method('findById')->with(100)->willReturn($this->createConditionalQuestion());
+		$this->questionMapper->method('findByParentQuestion')->with(100)->willReturn([
+			$this->createSubQuestion(101, 'branch-a', 1),
+			$this->createSubQuestion(102, 'branch-b', 1),
+		]);
+
+		$updated = [];
+		$this->questionMapper->expects($this->exactly(2))
+			->method('update')
+			->willReturnCallback(function (Question $question) use (&$updated) {
+				$updated[$question->getId()] = $question;
+				return $question;
+			});
+
+		$this->apiController->updateQuestion(1, 100, ['extraSettings' => [
+			'triggerType' => Constants::ANSWER_TYPE_MULTIPLEUNIQUE,
+			'branches' => [
+				['id' => 'branch-a', 'conditions' => [['optionId' => 10]], 'subQuestions' => [['id' => 101]]],
+			],
+		]]);
+
+		// Only the subquestion of the removed branch is deleted
+		$this->assertSame([102, 100], array_keys($updated));
+		$this->assertSame(0, $updated[102]->getOrder());
+		// Subquestions are stored as rows, not as a copy in the branches
+		$this->assertSame(
+			[['id' => 'branch-a', 'conditions' => [['optionId' => 10]]]],
+			$updated[100]->getExtraSettings()['branches'],
+		);
+	}
+
+	public function testUpdateQuestionRemovedBranchDeletesFilesOfSubquestions(): void {
+		$this->mockEditableForm();
+		$this->formsService->method('areExtraSettingsValid')->willReturn(true);
+		$fileSubQuestion = $this->createSubQuestion(102, 'branch-b', 1);
+		$fileSubQuestion->setType(Constants::ANSWER_TYPE_FILE);
+		$this->questionMapper->method('findById')->with(100)->willReturn($this->createConditionalQuestion());
+		$this->questionMapper->method('findByParentQuestion')->with(100)->willReturn([$fileSubQuestion]);
+
+		// Like for a deleted file question, the uploaded files are deleted
+		$this->jobList->expects($this->once())
+			->method('add')
+			->with(\OCA\Forms\BackgroundJob\DeleteQuestionFoldersJob::class, ['formId' => 1, 'questionId' => 102, 'ownerId' => 'currentUser']);
+
+		$this->apiController->updateQuestion(1, 100, ['extraSettings' => [
+			'triggerType' => Constants::ANSWER_TYPE_MULTIPLEUNIQUE,
+			'branches' => [['id' => 'branch-a', 'conditions' => [['optionId' => 10]]]],
+		]]);
+	}
+
+	public function testDeleteConditionalQuestionDeletesFilesOfSubquestions(): void {
+		$form = $this->mockEditableForm();
+		$form->setConfirmationEmailQuestionId(102);
+		$fileSubQuestion = $this->createSubQuestion(101, 'branch-a', 1);
+		$fileSubQuestion->setType(Constants::ANSWER_TYPE_FILE);
+		$this->questionMapper->method('findById')->with(100)->willReturn($this->createConditionalQuestion());
+		$this->questionMapper->method('findByParentQuestion')->with(100)->willReturn([
+			$fileSubQuestion,
+			$this->createSubQuestion(102, 'branch-b', 1),
+		]);
+		$this->questionMapper->method('findByForm')->willReturn([]);
+
+		$this->jobList->expects($this->once())
+			->method('add')
+			->with(\OCA\Forms\BackgroundJob\DeleteQuestionFoldersJob::class, ['formId' => 1, 'questionId' => 101, 'ownerId' => 'currentUser']);
+
+		$this->apiController->deleteQuestion(1, 100);
+		// A deleted subquestion can not be the recipient of the confirmation email
+		$this->assertNull($form->getConfirmationEmailQuestionId());
+	}
+
+	public function testDeleteSubQuestionRenumbersItsBranch(): void {
+		$this->mockEditableForm();
+		$this->questionMapper->method('findById')->with(101)->willReturn($this->createSubQuestion(101, 'branch-a', 1));
+		$sibling = $this->createSubQuestion(102, 'branch-a', 2);
+		$this->questionMapper->expects($this->once())
+			->method('findByBranch')
+			->with(100, 'branch-a')
+			->willReturn([$sibling]);
+		$this->questionMapper->expects($this->never())->method('findByForm');
+
+		$this->apiController->deleteQuestion(1, 101);
+		$this->assertSame(1, $sibling->getOrder());
+	}
+
+	public function testCloneConditionalQuestionCopiesSubquestionsAndOptions(): void {
+		$this->mockEditableForm();
+		$source = $this->createConditionalQuestion();
+		$subQuestion = $this->createSubQuestion(101, 'branch-a', 1);
+
+		$this->questionMapper->method('findById')->with(100)->willReturn($source);
+		$this->questionMapper->method('findByForm')->with(1)->willReturn([$source]);
+		$this->questionMapper->method('findByParentQuestion')->with(100)->willReturn([$subQuestion]);
+
+		$sourceOption = fn (int $id) => \OCA\Forms\Db\Option::fromParams(['id' => $id, 'questionId' => 100, 'text' => 'Option ' . $id, 'order' => $id]);
+		$this->optionMapper->method('findByQuestion')
+			->willReturnCallback(fn (int $questionId) => $questionId === 100 ? [$sourceOption(10), $sourceOption(11)] : []);
+		$nextOptionId = 20;
+		$this->optionMapper->method('insert')->willReturnCallback(function ($option) use (&$nextOptionId) {
+			$option->setId($nextOptionId++);
+			return $option;
+		});
+
+		$inserted = [];
+		$nextQuestionId = 200;
+		$this->questionMapper->expects($this->exactly(2))
+			->method('insert')
+			->willReturnCallback(function (Question $question) use (&$inserted, &$nextQuestionId) {
+				$question->setId($nextQuestionId++);
+				$inserted[] = $question;
+				return $question;
+			});
+		$this->formsService->expects($this->once())
+			->method('getQuestion')
+			->with(200)
+			->willReturn(['id' => 200, 'extraSettings' => ['branches' => []]]);
+
+		$this->apiController->newQuestion(1, null, null, '', 100);
+
+		[$copy, $subCopy] = $inserted;
+		// The branch conditions point to the options of the copy
+		$this->assertSame(
+			[['optionId' => 20]],
+			$copy->getExtraSettings()['branches'][0]['conditions'],
+		);
+		$this->assertSame(200, $subCopy->getParentQuestionId());
+		$this->assertSame('branch-a', $subCopy->getBranchId());
+	}
+
+	public function testReorderSubQuestions(): void {
+		$form = $this->mockEditableForm();
+		$first = $this->createSubQuestion(101, 'branch-a', 1);
+		$second = $this->createSubQuestion(102, 'branch-a', 2);
+		$this->questionMapper->method('findByBranch')->with(100, 'branch-a')->willReturn([$first, $second]);
+		$this->questionMapper->method('findById')->willReturnMap([[100, $this->createConditionalQuestion()], [101, $first], [102, $second]]);
+		$this->questionMapper->expects($this->exactly(2))->method('update');
+		$this->formMapper->expects($this->once())->method('update')->with($form);
+
+		$response = $this->apiController->reorderSubQuestions(1, 'branch-a', 100, [102, 101]);
+
+		$this->assertSame(['102' => ['order' => 1], '101' => ['order' => 2]], $response->getData());
+		$this->assertSame(2, $first->getOrder());
+		$this->assertSame(1, $second->getOrder());
+	}
+
+	public static function dataReorderSubQuestionsRejects(): array {
+		return [
+			'duplicates' => [[101, 101], OCSBadRequestException::class, null],
+			'wrong length' => [[101], OCSBadRequestException::class, null],
+			'unknown question' => [[101, 999], OCSNotFoundException::class, null],
+			'other form' => [[101, 102], OCSBadRequestException::class, 'formId'],
+			'other parent' => [[101, 102], OCSBadRequestException::class, 'parentQuestionId'],
+			'other branch' => [[101, 102], OCSBadRequestException::class, 'branchId'],
+			'deleted' => [[101, 102], OCSBadRequestException::class, 'order'],
+			'parent of other form' => [[101, 102], OCSBadRequestException::class, 'parent'],
+		];
+	}
+
+	/**
+	 * @dataProvider dataReorderSubQuestionsRejects
+	 */
+	public function testReorderSubQuestionsRejects(array $newOrder, string $exception, ?string $foreignKey): void {
+		$this->mockEditableForm();
+		$parent = $this->createConditionalQuestion();
+		$first = $this->createSubQuestion(101, 'branch-a', 1);
+		$second = $this->createSubQuestion(102, 'branch-a', 2);
+		match ($foreignKey) {
+			'formId' => $second->setFormId(2),
+			'parentQuestionId' => $second->setParentQuestionId(200),
+			'branchId' => $second->setBranchId('branch-b'),
+			'order' => $second->setOrder(0),
+			// Nothing is told about the branches of other forms
+			'parent' => $parent->setFormId(2),
+			null => null,
+		};
+		$this->questionMapper->method('findByBranch')->willReturn([$first, $second]);
+		$this->questionMapper->method('findById')->willReturnCallback(fn (int $id) => match ($id) {
+			100 => $parent,
+			101 => $first,
+			102 => $second,
+			default => throw new DoesNotExistException('not found'),
+		});
+		$this->questionMapper->expects($this->never())->method('update');
+
+		$this->expectException($exception);
+		$this->apiController->reorderSubQuestions(1, 'branch-a', 100, $newOrder);
+	}
+
+	public function testReorderSubQuestionsArchivedForm(): void {
+		$form = new Form();
+		$form->setId(1);
+		$this->formsService->method('getFormIfAllowed')->willReturn($form);
+		$this->formsService->method('isFormArchived')->willReturn(true);
+		$this->questionMapper->expects($this->never())->method('update');
+
+		$this->expectException(OCSForbiddenException::class);
+		$this->apiController->reorderSubQuestions(1, 'branch-a', 100, [101]);
+	}
 }
diff --git a/tests/Unit/FormsMigratorTest.php b/tests/Unit/FormsMigratorTest.php
index 10d6c4e788..2f3d01c99f 100644
--- a/tests/Unit/FormsMigratorTest.php
+++ b/tests/Unit/FormsMigratorTest.php
@@ -109,6 +109,7 @@ public static function dataExport() {
         "extraSettings": {},
         "options": [
           {
+            "id": 35,
             "text": "ans1"
           }
         ]
@@ -309,6 +310,119 @@ public function testImport(string $inputJson, int $expectedOpens) {
 		$this->formsMigrator->import($user, $importSource, $output);
 	}
 
+	public function testExportListsSubquestionsAsQuestions(): void {
+		$form = new Form();
+		$form->setId(42);
+		$form->setOwnerId('someUser');
+		$form->setAccess(['permitAllUsers' => false, 'showToAllUsers' => false]);
+
+		$user = $this->createMock(IUser::class);
+		$user->method('getUID')->willReturn('someUser');
+		$this->formMapper->method('findAllByOwnerId')->willReturn([$form]);
+		$this->submissionService->method('getSubmissions')->willReturn([]);
+		$this->formsService->method('getQuestions')->with(42)->willReturn([[
+			'id' => 14,
+			'formId' => 42,
+			'type' => 'conditional',
+			'extraSettings' => ['branches' => [[
+				'id' => 'branch-1',
+				'conditions' => [['optionId' => 35]],
+				'subQuestions' => [['id' => 15, 'formId' => 42, 'parentQuestionId' => 14, 'branchId' => 'branch-1', 'options' => []]],
+			]]],
+			'options' => [['id' => 35, 'questionId' => 14, 'text' => 'Yes']],
+		]]);
+
+		$exportDestination = $this->createMock(IExportDestination::class);
+		$exportDestination->expects($this->once())
+			->method('addFileContents')
+			->willReturnCallback(function ($path, $jsonData): void {
+				$questions = json_decode($jsonData, true)[0]['questions'];
+				$this->assertSame([14, 15], array_column($questions, 'id'));
+				$this->assertSame([['id' => 'branch-1', 'conditions' => [['optionId' => 35]]]], $questions[0]['extraSettings']['branches']);
+				$this->assertSame([['id' => 35, 'text' => 'Yes']], $questions[0]['options']);
+				$this->assertSame(14, $questions[1]['parentQuestionId']);
+				$this->assertSame('branch-1', $questions[1]['branchId']);
+			});
+
+		$this->formsMigrator->export($user, $exportDestination, $this->createMock(OutputInterface::class));
+	}
+
+	public function testImportConditionalQuestion(): void {
+		$inputJson = '[{"title":"Link","description":"","created":1646251830,"access":{"permitAllUsers":false,"showToAllUsers":false},"expires":0,"state":0,"isAnonymous":false,"submitMultiple":false,"allowEditSubmissions":false,"showExpiration":false,"lastUpdated":123456789,'
+			. '"questions":['
+			. '{"id":14,"order":1,"type":"conditional","isRequired":false,"text":"Pets?","description":"","extraSettings":{"triggerType":"multiple_unique","branches":[{"id":"branch-1","conditions":[{"optionId":35}]}]},"options":[{"id":35,"text":"Yes"}]},'
+			. '{"id":15,"order":1,"type":"short","isRequired":false,"text":"Name?","description":"","extraSettings":{},"options":[],"parentQuestionId":14,"branchId":"branch-1"}'
+			. '],'
+			. '"submissions":[{"userId":"anyUser@localhost","timestamp":1651354059,"answers":[{"questionId":14,"text":"Yes"},{"questionId":15,"text":"Rex"}]}]}]';
+
+		$user = $this->createMock(IUser::class);
+		$user->method('getUID')->willReturn('someUser');
+		$importSource = $this->createMock(IImportSource::class);
+		$importSource->method('getMigratorVersion')->willReturn(1);
+		$importSource->method('getFileContents')->willReturn($inputJson);
+
+		$this->formMapper->method('insert')->willReturnCallback(function (Form $form) {
+			$form->setId(7);
+			return $form;
+		});
+		$questions = [];
+		$this->questionMapper->expects($this->exactly(2))
+			->method('insert')
+			->willReturnCallback(function ($question) use (&$questions) {
+				$question->setId(100 + count($questions));
+				$questions[] = $question;
+				return $question;
+			});
+		$this->optionMapper->method('insert')->willReturnCallback(function ($option) {
+			$option->setId(500);
+			return $option;
+		});
+		// The branch conditions are pointed to the imported option
+		$this->questionMapper->expects($this->once())
+			->method('update')
+			->willReturnCallback(function ($question) {
+				$this->assertSame(100, $question->getId());
+				$this->assertSame([['id' => 'branch-1', 'conditions' => [['optionId' => 500]]]], $question->getExtraSettings()['branches']);
+				return $question;
+			});
+		$answerQuestionIds = [];
+		$this->answerMapper->method('insert')->willReturnCallback(function ($answer) use (&$answerQuestionIds) {
+			$answerQuestionIds[] = $answer->getQuestionId();
+			return $answer;
+		});
+
+		$this->formsMigrator->import($user, $importSource, $this->createMock(OutputInterface::class));
+
+		$this->assertSame(100, $questions[1]->getParentQuestionId());
+		$this->assertSame('branch-1', $questions[1]->getBranchId());
+		$this->assertSame([100, 101], $answerQuestionIds);
+	}
+
+	public function testImportSkipsAnswersOfQuestionsNotExported(): void {
+		$inputJson = '[{"title":"Link","description":"","created":1646251830,"access":{"permitAllUsers":false,"showToAllUsers":false},"expires":0,"state":0,"isAnonymous":false,"submitMultiple":false,"allowEditSubmissions":false,"showExpiration":false,"lastUpdated":123456789,'
+			. '"questions":[{"id":14,"order":1,"type":"short","isRequired":false,"text":"Name?","description":"","extraSettings":{},"options":[]}],'
+			. '"submissions":[{"userId":"anyUser@localhost","timestamp":1651354059,"answers":[{"questionId":14,"text":"Ann"},{"questionId":13,"text":"Answer of a deleted question"}]}]}]';
+
+		$user = $this->createMock(IUser::class);
+		$user->method('getUID')->willReturn('someUser');
+		$importSource = $this->createMock(IImportSource::class);
+		$importSource->method('getMigratorVersion')->willReturn(1);
+		$importSource->method('getFileContents')->willReturn($inputJson);
+		$this->questionMapper->method('insert')->willReturnCallback(function ($question) {
+			$question->setId(100);
+			return $question;
+		});
+
+		$this->answerMapper->expects($this->once())
+			->method('insert')
+			->willReturnCallback(function ($answer) {
+				$this->assertSame(100, $answer->getQuestionId());
+				return $answer;
+			});
+
+		$this->formsMigrator->import($user, $importSource, $this->createMock(OutputInterface::class));
+	}
+
 	public function testImport_NoVersion() {
 		$user = $this->createMock(IUser::class);
 		$importSource = $this->createMock(IImportSource::class);
diff --git a/tests/Unit/Service/ConfirmationEmailServiceTest.php b/tests/Unit/Service/ConfirmationEmailServiceTest.php
index afc8198724..b6a0e37b11 100644
--- a/tests/Unit/Service/ConfirmationEmailServiceTest.php
+++ b/tests/Unit/Service/ConfirmationEmailServiceTest.php
@@ -310,6 +310,65 @@ public function testSendQueuesJobWithCustomSubjectAndBodyAndPlaceholders(): void
 		$this->service->send($form, $submission);
 	}
 
+	public function testSendReplacesPlaceholdersOfSubquestions(): void {
+		$form = Form::fromParams([
+			'id' => 1,
+			'title' => 'Survey',
+			'confirmationEmailEnabled' => true,
+			'confirmationEmailQuestionId' => 5,
+			'confirmationEmailBody' => 'Your pet: {pet}',
+		]);
+		$submission = new Submission();
+		$submission->setId(10);
+
+		$this->configService->method('getAllowConfirmationEmail')->willReturn(true);
+		$this->configService->method('getConfirmationEmailRateLimit')->willReturn(3);
+		$this->questionMapper->expects($this->once())
+			->method('findByForm')
+			->with(1, false, true)
+			->willReturn([
+				$this->createQuestionEntity([
+					'id' => 5,
+					'type' => Constants::ANSWER_TYPE_SHORT,
+					'text' => 'Email',
+					'name' => 'email',
+					'extraSettings' => ['validationType' => 'email'],
+				]),
+				$this->createQuestionEntity([
+					'id' => 7,
+					'type' => Constants::ANSWER_TYPE_SHORT,
+					'text' => 'Pet name',
+					'name' => 'pet',
+					'parentQuestionId' => 6,
+					'branchId' => 'branch-1',
+				]),
+			]);
+
+		$petAnswer = new Answer();
+		$petAnswer->setSubmissionId(10);
+		$petAnswer->setQuestionId(7);
+		$petAnswer->setText('Rex');
+
+		$this->answerMapper->method('findBySubmission')->willReturn([
+			$this->makeEmailAnswer(10, 5, 'alice@example.com'),
+			$petAnswer,
+		]);
+		$this->emailValidator->method('isValid')->willReturn(true);
+		$this->cache->method('add')->willReturn(true);
+
+		$this->jobList->expects($this->once())
+			->method('add')
+			->with(
+				SendConfirmationMailJob::class,
+				$this->callback(function (array $payload): bool {
+					$this->assertSame('Your pet: Rex', $payload['body']);
+					return true;
+				})
+			);
+
+		$this->service->send($form, $submission);
+	}
+
 	public function testSendDoesNothingWhenRateLimitExceeded(): void {
 		$form = Form::fromParams([
 			'id' => 1,
diff --git a/tests/Unit/Service/FormsServiceTest.php b/tests/Unit/Service/FormsServiceTest.php
index 04185d43db..47b70ba704 100644
--- a/tests/Unit/Service/FormsServiceTest.php
+++ b/tests/Unit/Service/FormsServiceTest.php
@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 /**
- * SPDX-FileCopyrightText: 2021 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2021-2026 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
@@ -234,6 +234,8 @@ public static function dataGetForm() {
 							]
 						],
 						'accept' => [],
+						'parentQuestionId' => null,
+						'branchId' => null,
 					],
 					[
 						'id' => 2,
@@ -247,6 +249,8 @@ public static function dataGetForm() {
 						'name' => 'city',
 						'options' => [],
 						'accept' => [],
+						'parentQuestionId' => null,
+						'branchId' => null,
 					]
 				],
 				'shares' => [
@@ -1900,6 +1904,157 @@ public static function dataAreExtraSettingsValid() {
 				'questionType' => Constants::ANSWER_TYPE_LINEARSCALE,
 				'expected' => false
 			],
+			// Conditional question tests
+			'valid-conditional-dropdown-trigger' => [
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+					'branches' => [
+						['id' => 'branch-1', 'conditions' => [['type' => 'option_selected', 'optionId' => 1]]],
+						['id' => 'branch-2', 'conditions' => [['type' => 'option_selected', 'optionId' => 2]]]
+					]
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => true
+			],
+			'valid-conditional-multiple-unique-trigger' => [
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_MULTIPLEUNIQUE,
+					'branches' => [
+						['id' => 'branch-1', 'conditions' => [['type' => 'option_selected', 'optionId' => 5]]]
+					]
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => true
+			],
+			'invalid-conditional-missing-triggerType' => [
+				'extraSettings' => [
+					'branches' => [
+						['id' => 'branch-1', 'conditions' => [['optionId' => 1]]]
+					]
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
+			'invalid-conditional-missing-branches' => [
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_DROPDOWN
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
+			'invalid-conditional-invalid-triggerType' => [
+				'extraSettings' => [
+					'triggerType' => 'invalid_type',
+					'branches' => [
+						['id' => 'branch-1', 'conditions' => [['optionId' => 1]]]
+					]
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
+			'invalid-conditional-nested-not-allowed' => [
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_CONDITIONAL,
+					'branches' => [
+						['id' => 'branch-1', 'conditions' => [['optionId' => 1]]]
+					]
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
+			'invalid-conditional-branch-missing-id' => [
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+					'branches' => [
+						['conditions' => [['optionId' => 1]]]
+					]
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
+			'invalid-conditional-branch-missing-conditions' => [
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+					'branches' => [
+						['id' => 'branch-1']
+					]
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
+			'invalid-conditional-branches-not-array' => [
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+					'branches' => 'not-an-array'
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
+			'invalid-conditional-triggerType-not-string' => [
+				'extraSettings' => [
+					'triggerType' => 123,
+					'branches' => [
+						['id' => 'branch-1', 'conditions' => [['optionId' => 1]]]
+					]
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
+			'invalid-conditional-extra-settings-key' => [
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+					'branches' => [
+						['id' => 'branch-1', 'conditions' => [['optionId' => 1]]]
+					],
+					'invalidKey' => 'value'
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
+			'invalid-conditional-condition-type-of-other-trigger' => [
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+					'branches' => [
+						['id' => 'branch-1', 'conditions' => [['type' => 'value_range', 'min' => 1, 'max' => 3]]]
+					]
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
+			'invalid-conditional-option-id-not-a-number' => [
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+					'branches' => [
+						['id' => 'branch-1', 'conditions' => [['optionId' => ['nested']]]]
+					]
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
+			'invalid-conditional-branch-empty-id' => [
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+					'branches' => [['id' => '', 'conditions' => []]],
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
+			'invalid-conditional-branch-id-too-long' => [
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+					'branches' => [['id' => str_repeat('b', 65), 'conditions' => []]],
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
+			'invalid-conditional-duplicate-branch-ids' => [
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+					'branches' => [['id' => 'branch-1', 'conditions' => []], ['id' => 'branch-1', 'conditions' => []]],
+				],
+				'questionType' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'expected' => false
+			],
 		];
 	}
 
@@ -2003,10 +2158,168 @@ public function testGetQuestionsHandlesDoesNotExistException(): void {
 		$this->assertEmpty($result);
 	}
 
-	private function createQuestionEntity(array $data): MockObject {
-		$questionEntity = $this->createMock(Question::class);
-		$questionEntity->method('read')->willReturn($data);
+	public function testGetQuestionsWithConditionalQuestion(): void {
+		$conditionalQuestionData = [
+			'id' => 100,
+			'formId' => 1,
+			'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+			'text' => 'Conditional Q',
+			'order' => 1,
+			'isRequired' => true,
+			'name' => '',
+			'description' => '',
+			'extraSettings' => [
+				'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+				'branches' => [
+					['id' => 'branch-a', 'conditions' => [['type' => 'option_selected', 'optionId' => 10]]],
+					['id' => 'branch-b', 'conditions' => [['type' => 'option_selected', 'optionId' => 11]]]
+				]
+			],
+			'parentQuestionId' => null,
+			'branchId' => null,
+		];
+
+		$subQuestionData = [
+			'id' => 101,
+			'formId' => 1,
+			'type' => 'short',
+			'text' => 'Sub Q in branch A',
+			'order' => 1,
+			'isRequired' => false,
+			'name' => '',
+			'description' => '',
+			'extraSettings' => [],
+			'parentQuestionId' => 100,
+			'branchId' => 'branch-a',
+		];
+
+		$conditionalQuestion = $this->createQuestionEntity($conditionalQuestionData);
+		$subQuestion = $this->createQuestionEntity($subQuestionData);
+
+		// Top-level questions and subquestions come from one query
+		$this->questionMapper->method('findByForm')->with(1, false, true)->willReturn([$conditionalQuestion, $subQuestion]);
+		$this->optionMapper->method('findByQuestions')->willReturn([]);
+
+		$result = $this->formsService->getQuestions(1);
+
+		$this->assertCount(1, $result);
+		$this->assertEquals(Constants::ANSWER_TYPE_CONDITIONAL, $result[0]['type']);
+		$this->assertArrayHasKey('extraSettings', $result[0]);
+		$this->assertArrayHasKey('branches', $result[0]['extraSettings']);
+
+		// Verify subquestion is attached to branch-a
+		$branchA = null;
+		foreach ($result[0]['extraSettings']['branches'] as $branch) {
+			if ($branch['id'] === 'branch-a') {
+				$branchA = $branch;
+				break;
+			}
+		}
+		$this->assertNotNull($branchA);
+		$this->assertArrayHasKey('subQuestions', $branchA);
+		$this->assertCount(1, $branchA['subQuestions']);
+		$this->assertEquals('Sub Q in branch A', $branchA['subQuestions'][0]['text']);
+
+		// Branch-b should have empty subQuestions
+		$branchB = null;
+		foreach ($result[0]['extraSettings']['branches'] as $branch) {
+			if ($branch['id'] === 'branch-b') {
+				$branchB = $branch;
+				break;
+			}
+		}
+		$this->assertNotNull($branchB);
+		$this->assertArrayHasKey('subQuestions', $branchB);
+		$this->assertEmpty($branchB['subQuestions']);
+	}
+
+	public function testGetQuestionsWithConditionalSubQuestionFile(): void {
+		$conditionalQuestionData = [
+			'id' => 100,
+			'formId' => 1,
+			'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+			'text' => 'Conditional Q',
+			'order' => 1,
+			'isRequired' => true,
+			'name' => '',
+			'description' => '',
+			'extraSettings' => [
+				'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+				'branches' => [
+					['id' => 'branch-a', 'conditions' => [['type' => 'option_selected', 'optionId' => 10]]]
+				]
+			],
+			'parentQuestionId' => null,
+			'branchId' => null,
+		];
+
+		$fileSubQuestionData = [
+			'id' => 101,
+			'formId' => 1,
+			'type' => Constants::ANSWER_TYPE_FILE,
+			'text' => 'Upload file',
+			'order' => 1,
+			'isRequired' => false,
+			'name' => '',
+			'description' => '',
+			'extraSettings' => [
+				'allowedFileTypes' => ['image', 'application/pdf'],
+				'allowedFileExtensions' => ['txt', 'doc'],
+			],
+			'parentQuestionId' => 100,
+			'branchId' => 'branch-a',
+		];
+
+		$conditionalQuestion = $this->createQuestionEntity($conditionalQuestionData);
+		$fileSubQuestion = $this->createQuestionEntity($fileSubQuestionData);
+
+		// Top-level questions and subquestions come from one query
+		$this->questionMapper->method('findByForm')->with(1, false, true)->willReturn([$conditionalQuestion, $fileSubQuestion]);
+		$this->optionMapper->method('findByQuestions')->willReturn([]);
+
+		$result = $this->formsService->getQuestions(1);
+
+		$this->assertCount(1, $result);
+		$branchA = $result[0]['extraSettings']['branches'][0];
+		$this->assertCount(1, $branchA['subQuestions']);
+
+		$fileQuestion = $branchA['subQuestions'][0];
+		$this->assertEquals(Constants::ANSWER_TYPE_FILE, $fileQuestion['type']);
+		$this->assertArrayHasKey('accept', $fileQuestion);
+		// Should have image/*, application/pdf, .txt, .doc
+		$this->assertContains('image/*', $fileQuestion['accept']);
+		$this->assertContains('application/pdf', $fileQuestion['accept']);
+		$this->assertContains('.txt', $fileQuestion['accept']);
+		$this->assertContains('.doc', $fileQuestion['accept']);
+	}
+
+	private function createQuestionEntity(array $data): Question {
+		$questionEntity = Question::fromParams($data);
+		$questionEntity->setId($data['id']);
 		return $questionEntity;
 	}
 
+	public function testGetQuestionSkipsSubquestionsOfOtherForms(): void {
+		$conditionalQuestion = $this->createQuestionEntity([
+			'id' => 100,
+			'formId' => 1,
+			'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+			'text' => 'Conditional Q',
+			'order' => 1,
+			'extraSettings' => [
+				'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+				'branches' => [['id' => 'branch-a', 'conditions' => [['optionId' => 10]]]],
+			],
+		]);
+		$ownSubQuestion = $this->createQuestionEntity(['id' => 101, 'formId' => 1, 'type' => 'short', 'text' => 'Own', 'order' => 1, 'parentQuestionId' => 100, 'branchId' => 'branch-a']);
+		$otherSubQuestion = $this->createQuestionEntity(['id' => 201, 'formId' => 2, 'type' => 'short', 'text' => 'Other form', 'order' => 2, 'parentQuestionId' => 100, 'branchId' => 'branch-a']);
+
+		$this->questionMapper->method('findById')->with(100)->willReturn($conditionalQuestion);
+		$this->questionMapper->method('findByParentQuestion')->with(100)->willReturn([$ownSubQuestion, $otherSubQuestion]);
+		$this->optionMapper->method('findByQuestions')->willReturn([]);
+
+		$question = $this->formsService->getQuestion(100);
+
+		$this->assertSame(['Own'], array_column($question['extraSettings']['branches'][0]['subQuestions'], 'text'));
+	}
 }
diff --git a/tests/Unit/Service/SubmissionServiceTest.php b/tests/Unit/Service/SubmissionServiceTest.php
index e3d19a7e4f..bc76a1fcb3 100644
--- a/tests/Unit/Service/SubmissionServiceTest.php
+++ b/tests/Unit/Service/SubmissionServiceTest.php
@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 /**
- * SPDX-FileCopyrightText: 2021 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2021-2026 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
@@ -19,6 +19,7 @@
 use OCA\Forms\Db\QuestionMapper;
 use OCA\Forms\Db\Submission;
 use OCA\Forms\Db\SubmissionMapper;
+use OCA\Forms\Db\UploadedFile;
 use OCA\Forms\Db\UploadedFileMapper;
 use OCA\Forms\Service\FormsService;
 use OCA\Forms\Service\SubmissionService;
@@ -609,6 +610,38 @@ public static function dataGetSubmissionsData() {
 				"1","user1","User 1","1973-11-29T22:33:09+01:00","",""
 				'
 			],
+			'conditional-subquestions-follow-their-question' => [
+				// Questions, sorted by order like the mapper returns them: subquestions are ordered within their branch
+				[
+					['id' => 1, 'type' => 'conditional', 'text' => 'Cond', 'order' => 1, 'extraSettings' => [
+						'triggerType' => 'short',
+						'branches' => [['id' => 'b1', 'conditions' => []], ['id' => 'b2', 'conditions' => []]],
+					]],
+					['id' => 3, 'type' => 'short', 'text' => 'Sub B', 'order' => 1, 'parentQuestionId' => 1, 'branchId' => 'b2'],
+					['id' => 4, 'type' => 'short', 'text' => 'Sub A', 'order' => 1, 'parentQuestionId' => 1, 'branchId' => 'b1'],
+					['id' => 2, 'type' => 'short', 'text' => 'Top 2', 'order' => 2],
+					['id' => 5, 'type' => 'short', 'text' => 'Removed branch', 'order' => 2, 'parentQuestionId' => 1, 'branchId' => 'b0'],
+				],
+				// Array of Submissions incl. Answers
+				[
+					[
+						'id' => 1,
+						'userId' => 'user1',
+						'timestamp' => 123456789,
+						'answers' => [
+							['questionId' => 1, 'text' => 'yes'],
+							['questionId' => 4, 'text' => 'A'],
+							['questionId' => 2, 'text' => 'T'],
+						]
+					],
+				],
+				// Expected CSV-Result: subquestions right after their question, in branch order
+				'
+				"Submission ID","User ID","User display name","Timestamp","Cond","Sub A","Sub B","Top 2"
+				"submission_id","user_id","user_display_name","timestamp","question-id-1","question-id-4","question-id-3","question-id-2"
+				"1","user1","User 1","1973-11-29T22:33:09+01:00","yes","A","","T"
+				'
+			],
 		];
 	}
 	/**
@@ -906,6 +939,33 @@ public static function dataValidateSubmission() {
 				// Expected Result
 				'Answer for non-existent question with ID 2.',
 			],
+			'question-id-in-other-notation' => [
+				// Questions
+				[
+					['id' => 1, 'type' => 'short', 'text' => 'q1', 'isRequired' => false, 'extraSettings' => ['validationType' => 'email']]
+				],
+				// Answers - the key is not the question id
+				[
+					'1.0' => ['not an email']
+				],
+				// Expected Result
+				'Answer for non-existent question with ID 1.',
+			],
+			'option-id-in-other-notation' => [
+				// Questions
+				[
+					['id' => 1, 'type' => 'multiple_unique', 'text' => 'q1', 'isRequired' => false, 'options' => [
+						['id' => 3],
+						['id' => 5]
+					]],
+				],
+				// Answers
+				[
+					'1' => ['03']
+				],
+				// Expected Result
+				'Answer "03" for question "q1" is not a valid option.',
+			],
 			'invalid-multiple-too-many-answers' => [
 				// Questions
 				[
@@ -1402,6 +1462,319 @@ public static function dataValidateSubmission() {
 				// Expected Result – required question must be answered
 				'Question "Rank these" is required.',
 			],
+			// Conditional question tests
+			'valid-conditional-with-trigger-and-subquestions' => [
+				// Questions - conditional with dropdown trigger and subquestions in branches
+				[
+					[
+						'id' => 100,
+						'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+						'text' => 'Conditional Q',
+						'isRequired' => true,
+						'extraSettings' => [
+							'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+							'branches' => [
+								[
+									'id' => 'branch-1',
+									'conditions' => [['type' => 'option_selected', 'optionId' => 10]],
+									'subQuestions' => [
+										[
+											'id' => 101,
+											'type' => 'short',
+											'text' => 'Sub Q1',
+											'isRequired' => true,
+										]
+									]
+								],
+								[
+									'id' => 'branch-2',
+									'conditions' => [['type' => 'option_selected', 'optionId' => 11]],
+									'subQuestions' => [
+										[
+											'id' => 102,
+											'type' => 'short',
+											'text' => 'Sub Q2',
+											'isRequired' => true,
+										]
+									]
+								]
+							]
+						],
+						'options' => [
+							['id' => 10],
+							['id' => 11]
+						]
+					]
+				],
+				// Answers - trigger selects branch-1, so only subquestion 101 needs to be answered
+				[
+					'100' => [
+						'trigger' => ['10'],
+						'subQuestions' => [
+							'101' => ['Sub answer 1']
+						]
+					]
+				],
+				// Expected Result - valid
+				null,
+			],
+			'valid-conditional-optional-not-answered' => [
+				// Questions - optional conditional question
+				[
+					[
+						'id' => 100,
+						'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+						'text' => 'Conditional Q',
+						'isRequired' => false,
+						'extraSettings' => [
+							'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+							'branches' => [
+								[
+									'id' => 'branch-1',
+									'conditions' => [['type' => 'option_selected', 'optionId' => 10]],
+									'subQuestions' => []
+								]
+							]
+						],
+						'options' => [
+							['id' => 10]
+						]
+					]
+				],
+				// Answers - not answered at all
+				[],
+				// Expected Result - valid since optional
+				null,
+			],
+			'invalid-conditional-required-trigger-not-answered' => [
+				// Questions - required conditional question
+				[
+					[
+						'id' => 100,
+						'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+						'text' => 'Conditional Q',
+						'isRequired' => true,
+						'extraSettings' => [
+							'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+							'branches' => [
+								[
+									'id' => 'branch-1',
+									'conditions' => [['type' => 'option_selected', 'optionId' => 10]],
+									'subQuestions' => []
+								]
+							]
+						],
+						'options' => [
+							['id' => 10]
+						]
+					]
+				],
+				// Answers - not answered
+				[],
+				// Expected Result
+				'Question "Conditional Q" is required.',
+			],
+			'invalid-conditional-required-subquestion-not-answered' => [
+				// Questions - conditional with required subquestion in the branch
+				[
+					[
+						'id' => 100,
+						'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+						'text' => 'Conditional Q',
+						'isRequired' => true,
+						'extraSettings' => [
+							'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+							'branches' => [
+								[
+									'id' => 'branch-1',
+									'conditions' => [['type' => 'option_selected', 'optionId' => 10]],
+									'subQuestions' => [
+										[
+											'id' => 101,
+											'type' => 'short',
+											'text' => 'Sub Q1',
+											'isRequired' => true,
+										]
+									]
+								]
+							]
+						],
+						'options' => [
+							['id' => 10]
+						]
+					]
+				],
+				// Answers - trigger answered but subquestion not
+				[
+					'100' => [
+						'trigger' => ['10'],
+						'subQuestions' => []
+					]
+				],
+				// Expected Result
+				'Question "Sub Q1" is required.',
+			],
+			'valid-conditional-no-branch-matched' => [
+				// Questions - conditional where trigger value doesn't match any branch
+				[
+					[
+						'id' => 100,
+						'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+						'text' => 'Conditional Q',
+						'isRequired' => true,
+						'extraSettings' => [
+							'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+							'branches' => [
+								[
+									'id' => 'branch-1',
+									'conditions' => [['type' => 'option_selected', 'optionId' => 10]],
+									'subQuestions' => []
+								]
+							]
+						],
+						'options' => [
+							['id' => 10],
+							['id' => 11]
+						]
+					]
+				],
+				// Answers - trigger value 11 doesn't match any branch (only branch-1 matches 10)
+				[
+					'100' => [
+						'trigger' => ['11'],
+						'subQuestions' => []
+					]
+				],
+				// Expected Result - valid (no branch matched, but that's okay)
+				null,
+			],
+			'invalid-conditional-dropdown-number-trigger-activates-branch' => [
+				// Questions - dropdowns send option ids as numbers, the branch must still be active
+				[
+					[
+						'id' => 100,
+						'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+						'text' => 'Conditional Q',
+						'isRequired' => true,
+						'extraSettings' => [
+							'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+							'branches' => [
+								[
+									'id' => 'branch-1',
+									'conditions' => [['type' => 'option_selected', 'optionId' => 10]],
+									'subQuestions' => [
+										['id' => 101, 'type' => 'short', 'text' => 'Sub Q1', 'isRequired' => true],
+									],
+								],
+							],
+						],
+						'options' => [['id' => 10], ['id' => 11]],
+					],
+				],
+				// Answers - numeric trigger, required subquestion not answered
+				['100' => ['trigger' => [10], 'subQuestions' => []]],
+				// Expected Result
+				'Question "Sub Q1" is required.',
+			],
+			'invalid-conditional-unknown-trigger-option' => [
+				// Questions - the trigger is validated like a dropdown question
+				[
+					[
+						'id' => 100,
+						'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+						'text' => 'Conditional Q',
+						'isRequired' => false,
+						'extraSettings' => [
+							'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+							'branches' => [
+								['id' => 'branch-1', 'conditions' => [['type' => 'option_selected', 'optionId' => 10]], 'subQuestions' => []],
+							],
+						],
+						'options' => [['id' => 10]],
+					],
+				],
+				// Answers - not an option of the trigger
+				['100' => ['trigger' => ['totally-not-an-option'], 'subQuestions' => []]],
+				// Expected Result
+				'Answer "totally-not-an-option" for question "Conditional Q" is not a valid option.',
+			],
+			'invalid-conditional-required-empty-trigger' => [
+				// Questions - required conditional question
+				[
+					[
+						'id' => 100,
+						'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+						'text' => 'Conditional Q',
+						'isRequired' => true,
+						'extraSettings' => [
+							'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+							'branches' => [
+								['id' => 'branch-1', 'conditions' => [['type' => 'option_selected', 'optionId' => 10]], 'subQuestions' => []],
+							],
+						],
+						'options' => [['id' => 10]],
+					],
+				],
+				// Answers - sent, but the trigger is empty
+				['100' => ['trigger' => [], 'subQuestions' => []]],
+				// Expected Result
+				'Question "Conditional Q" is required.',
+			],
+			'invalid-conditional-answer-for-inactive-branch' => [
+				// Questions - two branches with one subquestion each
+				[
+					[
+						'id' => 100,
+						'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+						'text' => 'Conditional Q',
+						'isRequired' => false,
+						'extraSettings' => [
+							'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+							'branches' => [
+								[
+									'id' => 'branch-1',
+									'conditions' => [['type' => 'option_selected', 'optionId' => 10]],
+									'subQuestions' => [['id' => 101, 'type' => 'short', 'text' => 'Sub Q1', 'isRequired' => false]],
+								],
+								[
+									'id' => 'branch-2',
+									'conditions' => [['type' => 'option_selected', 'optionId' => 11]],
+									'subQuestions' => [['id' => 102, 'type' => 'short', 'text' => 'Sub Q2', 'isRequired' => false]],
+								],
+							],
+						],
+						'options' => [['id' => 10], ['id' => 11]],
+					],
+				],
+				// Answers - the subquestion of the inactive branch is answered
+				['100' => ['trigger' => ['10'], 'subQuestions' => ['102' => ['left over']]]],
+				// Expected Result
+				'Answer for non-existent question with ID 102.',
+			],
+			'invalid-conditional-trigger-not-a-list' => [
+				// Questions - the trigger option opens a branch with a required subquestion
+				[
+					[
+						'id' => 100,
+						'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+						'text' => 'Conditional Q',
+						'isRequired' => false,
+						'extraSettings' => [
+							'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+							'branches' => [[
+								'id' => 'branch-1',
+								'conditions' => [['optionId' => 10]],
+								'subQuestions' => [['id' => 101, 'type' => 'short', 'text' => 'Sub Q1', 'isRequired' => true]],
+							]],
+						],
+						'options' => [['id' => 10]],
+					],
+				],
+				// Answers - a trigger with keys would select the option without opening its branch
+				['100' => ['trigger' => ['1' => '10'], 'subQuestions' => []]],
+				// Expected Result
+				'Invalid answer for conditional question.',
+			],
 		];
 	}
 
@@ -1470,4 +1843,111 @@ public function testValidateSubmission_rejectsForeignUploadToken(): void {
 
 		$this->submissionService->validateSubmission($questions, $answers, 'alice', 7);
 	}
+
+	public static function dataFileUploadAuthorization(): array {
+		$cases = [];
+		foreach ([false, true] as $conditional) {
+			foreach ([false, true] as $required) {
+				foreach ([
+					'valid' => 'valid-upload-token',
+					'foreign' => 'attacker-token',
+					'missing' => null,
+					'empty' => '',
+				] as $name => $token) {
+					$case = ($conditional ? 'conditional' : 'ordinary') . '-'
+						. ($required ? 'required' : 'optional') . '-' . $name;
+					$cases[$case] = [$conditional, $required, $token];
+				}
+			}
+		}
+		return $cases;
+	}
+
+	/**
+	 * @dataProvider dataFileUploadAuthorization
+	 */
+	public function testValidateSubmission_fileUploadAuthorization(bool $conditional, bool $required, ?string $uploadToken): void {
+		$fileQuestion = [
+			'id' => 8,
+			'type' => Constants::ANSWER_TYPE_FILE,
+			'text' => 'File question',
+			'isRequired' => $required,
+			'extraSettings' => [],
+		];
+		$fileAnswer = [
+			'uploadedFileId' => '10',
+			'fileName' => 'attachment.rtf',
+		];
+		if ($uploadToken !== null) {
+			$fileAnswer['uploadToken'] = $uploadToken;
+		}
+		$questions = [$fileQuestion];
+		$answers = [8 => [$fileAnswer]];
+
+		if ($conditional) {
+			$questions = [[
+				'id' => 9,
+				'type' => Constants::ANSWER_TYPE_CONDITIONAL,
+				'text' => 'Conditional question',
+				'isRequired' => true,
+				'options' => [['id' => 11, 'text' => 'Yes']],
+				'extraSettings' => [
+					'triggerType' => Constants::ANSWER_TYPE_DROPDOWN,
+					'branches' => [[
+						'id' => 'file-branch',
+						'conditions' => [[
+							'type' => Constants::CONDITION_TYPE_OPTION_SELECTED,
+							'optionId' => 11,
+						]],
+						'subQuestions' => [$fileQuestion],
+					]],
+				],
+			]];
+			$answers = [9 => ['trigger' => ['11'], 'subQuestions' => $answers]];
+		}
+
+		$this->uploadedFileMapper->expects($this->never())
+			->method('getByUploadedFileId');
+		$this->uploadedFileMapper->expects($this->never())
+			->method('findByUploadedFileId');
+
+		$missingRequiredToken = $required && ($uploadToken === null || $uploadToken === '');
+		if ($missingRequiredToken) {
+			$this->uploadedFileMapper->expects($this->never())
+				->method('getForSubmission');
+		} else {
+			$lookup = $this->uploadedFileMapper->expects($this->once())
+				->method('getForSubmission')
+				->with($this->identicalTo(10), $this->identicalTo(7), $this->identicalTo(8), $uploadToken ?? '');
+			if ($uploadToken === 'valid-upload-token') {
+				$uploadedFile = new UploadedFile();
+				$uploadedFile->setId(10);
+				$uploadedFile->setFileId(99);
+				$lookup->willReturn($uploadedFile);
+			} else {
+				$lookup->willThrowException(new DoesNotExistException('Upload not found'));
+			}
+		}
+
+		if ($uploadToken === 'valid-upload-token') {
+			$folder = $this->createMock(Folder::class);
+			$folder->expects($this->once())
+				->method('getById')
+				->with(99)
+				->willReturn([$this->createMock(File::class)]);
+			$this->storage->expects($this->once())
+				->method('getUserFolder')
+				->with('alice')
+				->willReturn($folder);
+		} else {
+			$this->storage->expects($this->never())
+				->method('getUserFolder');
+			$this->expectException(\InvalidArgumentException::class);
+			$this->expectExceptionMessage($missingRequiredToken
+				? 'Question "File question" is required.'
+				: 'File "attachment.rtf" for question "File question" not exists anymore. Please delete and re-upload the file.');
+		}
+
+		$this->submissionService->validateSubmission($questions, $answers, 'alice', 7);
+	}
 };