diff --git a/i18n/en.pot b/i18n/en.pot
index 0090bc99..4d53e015 100644
--- a/i18n/en.pot
+++ b/i18n/en.pot
@@ -5,8 +5,8 @@ msgstr ""
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=(n != 1)\n"
-"POT-Creation-Date: 2024-10-09T10:56:24.909Z\n"
-"PO-Revision-Date: 2024-10-09T10:56:24.909Z\n"
+"POT-Creation-Date: 2024-10-16T14:36:22.158Z\n"
+"PO-Revision-Date: 2024-10-16T14:36:22.158Z\n"
 
 msgid "Low"
 msgstr ""
@@ -84,6 +84,9 @@ msgstr ""
 msgid "Cancel"
 msgstr ""
 
+msgid "Edit Action Plan"
+msgstr ""
+
 msgid "Edit Details"
 msgstr ""
 
@@ -186,13 +189,25 @@ msgstr ""
 msgid "Risk Assessment Questionnaire saved successfully"
 msgstr ""
 
+msgid "Incident Action Plan saved successfully"
+msgstr ""
+
+msgid "Incident Response Actions saved successfully"
+msgstr ""
+
 msgid "Incident Management Team Member saved successfully"
 msgstr ""
 
-msgid "Incident Action Plan"
+msgid "Create an incident action plan"
+msgstr ""
+
+msgid "No plan has been created for this incident"
 msgstr ""
 
-msgid "Cholera in NW Province, June 2023"
+msgid "Create IAP"
+msgstr ""
+
+msgid "Incident Action Plan"
 msgstr ""
 
 msgid "Incident Management Team Builder"
diff --git a/i18n/es.po b/i18n/es.po
index 9edfa351..d1247b77 100644
--- a/i18n/es.po
+++ b/i18n/es.po
@@ -1,7 +1,7 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: i18next-conv\n"
-"POT-Creation-Date: 2024-10-09T10:56:24.909Z\n"
+"POT-Creation-Date: 2024-10-15T13:56:24.806Z\n"
 "PO-Revision-Date: 2018-10-25T09:02:35.143Z\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
@@ -83,6 +83,9 @@ msgstr ""
 msgid "Cancel"
 msgstr ""
 
+msgid "Edit Action Plan"
+msgstr ""
+
 msgid "Edit Details"
 msgstr ""
 
@@ -185,12 +188,30 @@ msgstr ""
 msgid "Risk Assessment Questionnaire saved successfully"
 msgstr ""
 
+msgid "Incident Action Plan saved successfully"
+msgstr ""
+
+msgid "Incident Response Actions saved successfully"
+msgstr ""
+
+msgid "Create an incident action plan"
+msgstr ""
+
+msgid "No plan has been created for this incident"
+msgstr ""
+
+msgid "Create IAP"
+msgstr ""
+
 msgid "Incident Management Team Member saved successfully"
 msgstr ""
 
 msgid "Incident Action Plan"
 msgstr ""
 
+msgid "Incident Management Team Builder"
+msgstr ""
+
 msgid "Cholera in NW Province, June 2023"
 msgstr ""
 
diff --git a/src/CompositionRoot.ts b/src/CompositionRoot.ts
index 23d578f2..21556037 100644
--- a/src/CompositionRoot.ts
+++ b/src/CompositionRoot.ts
@@ -27,6 +27,9 @@ import { SaveEntityUseCase } from "./domain/usecases/SaveEntityUseCase";
 import { RiskAssessmentRepository } from "./domain/repositories/RiskAssessmentRepository";
 import { RiskAssessmentD2Repository } from "./data/repositories/RiskAssessmentD2Repository";
 import { RiskAssessmentTestRepository } from "./data/repositories/test/RiskAssessmentTestRepository";
+import { IncidentActionRepository } from "./domain/repositories/IncidentActionRepository";
+import { IncidentActionD2Repository } from "./data/repositories/IncidentActionD2Repository";
+import { IncidentActionTestRepository } from "./data/repositories/test/IncidentActionTestRepository";
 import { MapConfigRepository } from "./domain/repositories/MapConfigRepository";
 import { MapConfigD2Repository } from "./data/repositories/MapConfigD2Repository";
 import { MapConfigTestRepository } from "./data/repositories/test/MapConfigTestRepository";
@@ -42,6 +45,8 @@ import { AlertSyncDataStoreTestRepository } from "./data/repositories/test/Alert
 import { AlertSyncRepository } from "./domain/repositories/AlertSyncRepository";
 import { DataStoreClient } from "./data/DataStoreClient";
 import { GetTotalCardCountsUseCase } from "./domain/usecases/GetTotalCardCountsUseCase";
+import { GetIncidentActionByIdUseCase } from "./domain/usecases/GetIncidentActionByIdUseCase";
+import { UpdateIncidentResponseActionUseCase } from "./domain/usecases/UpdateIncidentResponseActionUseCase";
 import { RoleRepository } from "./domain/repositories/RoleRepository";
 import { RoleD2Repository } from "./data/repositories/RoleD2Repository";
 import { RoleTestRepository } from "./data/repositories/test/RoleTestRepository";
@@ -71,6 +76,7 @@ type Repositories = {
     teamMemberRepository: TeamMemberRepository;
     orgUnitRepository: OrgUnitRepository;
     riskAssessmentRepository: RiskAssessmentRepository;
+    incidentActionRepository: IncidentActionRepository;
     mapConfigRepository: MapConfigRepository;
     performanceOverviewRepository: PerformanceOverviewRepository;
     roleRepository: RoleRepository;
@@ -95,6 +101,10 @@ function getCompositionRoot(repositories: Repositories) {
                 repositories.optionsRepository
             ),
         },
+        incidentActionPlan: {
+            get: new GetIncidentActionByIdUseCase(repositories),
+            updateResponseAction: new UpdateIncidentResponseActionUseCase(repositories),
+        },
         incidentManagementTeam: {
             get: new GetIncidentManagementTeamByIdUseCase(repositories),
             deleteIncidentManagementTeamMemberRole:
@@ -135,6 +145,7 @@ export function getWebappCompositionRoot(api: D2Api) {
         teamMemberRepository: new TeamMemberD2Repository(api),
         orgUnitRepository: new OrgUnitD2Repository(api),
         riskAssessmentRepository: new RiskAssessmentD2Repository(api),
+        incidentActionRepository: new IncidentActionD2Repository(api),
         mapConfigRepository: new MapConfigD2Repository(api),
         performanceOverviewRepository: new PerformanceOverviewD2Repository(api, dataStoreClient),
         roleRepository: new RoleD2Repository(api),
@@ -156,6 +167,7 @@ export function getTestCompositionRoot() {
         teamMemberRepository: new TeamMemberTestRepository(),
         orgUnitRepository: new OrgUnitTestRepository(),
         riskAssessmentRepository: new RiskAssessmentTestRepository(),
+        incidentActionRepository: new IncidentActionTestRepository(),
         mapConfigRepository: new MapConfigTestRepository(),
         performanceOverviewRepository: new PerformanceOverviewTestRepository(),
         roleRepository: new RoleTestRepository(),
diff --git a/src/data/repositories/IncidentActionD2Repository.ts b/src/data/repositories/IncidentActionD2Repository.ts
new file mode 100644
index 00000000..701edb59
--- /dev/null
+++ b/src/data/repositories/IncidentActionD2Repository.ts
@@ -0,0 +1,253 @@
+import { D2Api } from "../../types/d2-api";
+import { Maybe } from "../../utils/ts-utils";
+import { apiToFuture, FutureData } from "../api-futures";
+import { Id } from "../../domain/entities/Ref";
+import {
+    RTSL_ZEBRA_INCIDENT_ACTION_PLAN_PROGRAM_STAGE_ID,
+    RTSL_ZEBRA_INCIDENT_RESPONSE_ACTION_PROGRAM_STAGE_ID,
+    RTSL_ZEBRA_ORG_UNIT_ID,
+    RTSL_ZEBRA_PROGRAM_ID,
+} from "./consts/DiseaseOutbreakConstants";
+import {
+    IncidentActionRepository,
+    UpdateIncidentResponseActionOptions,
+} from "../../domain/repositories/IncidentActionRepository";
+import {
+    mapDataElementsToIncidentActionPlan,
+    mapDataElementsToIncidentResponseActions,
+    mapIncidentActionToDataElements,
+} from "./utils/IncidentActionMapper";
+import { ActionPlanFormData, ResponseActionFormData } from "../../domain/entities/ConfigurableForm";
+import { getProgramStage } from "./utils/MetadataHelper";
+import { Future } from "../../domain/entities/generic/Future";
+import { Status, Verification } from "../../domain/entities/incident-action-plan/ResponseAction";
+import { assertOrError } from "./utils/AssertOrError";
+import { D2TrackerEvent } from "@eyeseetea/d2-api/api/trackerEvents";
+import { statusCodeMap, verificationCodeMap } from "./consts/IncidentActionConstants";
+
+export const incidentActionPlanIds = {
+    iapType: "wr1I51WTHhl",
+    phoecLevel: "KgTXZonQEsm",
+    criticalInfoRequirements: "sgZ6MgzCI7m",
+    planningAssumptions: "RZviL2uz1Wa",
+    responseObjectives: "giq2C0lvCza",
+    responseStrategies: "lbcbEZ8bEpK",
+    expectedResults: "sB1N7Nkm5Y1",
+    responseActivitiesNarrative: "RnWk88dYOXN",
+} as const;
+
+export type IncidentActionPlanDataValues = {
+    id: string;
+    iapType: Maybe<string>;
+    phoecLevel: Maybe<string>;
+    criticalInfoRequirements: Maybe<string>;
+    planningAssumptions: Maybe<string>;
+    responseObjectives: Maybe<string>;
+    responseStrategies: Maybe<string>;
+    expectedResults: Maybe<string>;
+    responseActivitiesNarrative: Maybe<string>;
+};
+
+export const incidentResponseActionsIds = {
+    mainTask: "k3FiTDWD18d",
+    subActivities: "i728CZUYlRB",
+    subPillar: "BQhCqEHOyej",
+    searchAssignRO: "Z9a067KbV5J",
+    dueDate: "i2M51y9qBoC",
+    timeLine: "xvWvQ3K1GVA",
+    status: "mUR4eNxgAwg",
+    verification: "M62NkbKXhqZ",
+};
+
+export type IncidentResponseActionDataValues = {
+    id: string;
+    mainTask: Maybe<string>;
+    subActivities: Maybe<string>;
+    subPillar: Maybe<string>;
+    searchAssignRO: Maybe<string>;
+    dueDate: Maybe<string>;
+    timeLine: Maybe<string>;
+    status: Maybe<Status>;
+    verification: Maybe<Verification>;
+};
+
+export class IncidentActionD2Repository implements IncidentActionRepository {
+    constructor(private api: D2Api) {}
+
+    private fields = {
+        event: true,
+        dataValues: {
+            dataElement: { id: true, code: true },
+            value: true,
+        },
+        trackedEntity: true,
+    };
+
+    getIncidentActionPlan(diseaseOutbreakId: Id): FutureData<Maybe<IncidentActionPlanDataValues>> {
+        return apiToFuture(
+            this.api.tracker.events.get({
+                program: RTSL_ZEBRA_PROGRAM_ID,
+                orgUnit: RTSL_ZEBRA_ORG_UNIT_ID,
+                trackedEntity: diseaseOutbreakId,
+                programStage: RTSL_ZEBRA_INCIDENT_ACTION_PLAN_PROGRAM_STAGE_ID,
+                fields: this.fields,
+            })
+        ).map(events => {
+            if (!events.instances[0]?.event) return undefined;
+
+            const plan: IncidentActionPlanDataValues = mapDataElementsToIncidentActionPlan(
+                events.instances[0].event,
+                events.instances[0].dataValues
+            );
+
+            return plan;
+        });
+    }
+
+    getIncidentResponseActions(
+        diseaseOutbreakId: Id
+    ): FutureData<IncidentResponseActionDataValues[]> {
+        return apiToFuture(
+            this.api.tracker.events.get({
+                program: RTSL_ZEBRA_PROGRAM_ID,
+                orgUnit: RTSL_ZEBRA_ORG_UNIT_ID,
+                trackedEntity: diseaseOutbreakId,
+                programStage: RTSL_ZEBRA_INCIDENT_RESPONSE_ACTION_PROGRAM_STAGE_ID,
+                fields: this.fields,
+            })
+        ).map(events => {
+            if (events.instances.length === 0) return [];
+
+            const responseActions: IncidentResponseActionDataValues[] =
+                mapDataElementsToIncidentResponseActions(events.instances);
+
+            return responseActions;
+        });
+    }
+
+    saveIncidentAction(
+        formData: ActionPlanFormData | ResponseActionFormData,
+        diseaseOutbreakId: Id
+    ): FutureData<void> {
+        const programStageId = this.getProgramStageByFormType(formData.type);
+
+        return getProgramStage(this.api, programStageId).flatMap(incidentResponse => {
+            const incidentDataElements = incidentResponse.objects[0]?.programStageDataElements;
+
+            if (!incidentDataElements)
+                return Future.error(new Error(`${formData.type} Program Stage metadata not found`));
+
+            //Get the enrollment Id for the disease outbreak
+            return apiToFuture(
+                this.api.tracker.enrollments.get({
+                    fields: {
+                        enrollment: true,
+                    },
+                    trackedEntity: diseaseOutbreakId,
+                    enrolledBefore: new Date().toISOString(),
+                    program: RTSL_ZEBRA_PROGRAM_ID,
+                    orgUnit: RTSL_ZEBRA_ORG_UNIT_ID,
+                })
+            ).flatMap(enrollmentResponse => {
+                const enrollmentId = enrollmentResponse.instances[0]?.enrollment;
+                if (!enrollmentId) {
+                    return Future.error(new Error(`Enrollment not found for Disease Outbreak`));
+                }
+
+                const events = mapIncidentActionToDataElements(
+                    formData,
+                    programStageId,
+                    diseaseOutbreakId,
+                    enrollmentId,
+                    incidentDataElements
+                );
+
+                return apiToFuture(
+                    this.api.tracker.post(
+                        { importStrategy: "CREATE_AND_UPDATE" },
+                        { events: Array.isArray(events) ? events : [events] }
+                    )
+                ).flatMap(saveResponse => {
+                    if (saveResponse.status === "ERROR" || !diseaseOutbreakId) {
+                        return Future.error(new Error(`Error saving Incident Action`));
+                    } else {
+                        return Future.success(undefined);
+                    }
+                });
+            });
+        });
+    }
+
+    updateIncidentResponseAction(options: UpdateIncidentResponseActionOptions): FutureData<void> {
+        const { diseaseOutbreakId, eventId, responseAction } = options;
+
+        return apiToFuture(
+            this.api.tracker.events.get({
+                program: RTSL_ZEBRA_PROGRAM_ID,
+                orgUnit: RTSL_ZEBRA_ORG_UNIT_ID,
+                trackedEntity: diseaseOutbreakId,
+                programStage: RTSL_ZEBRA_INCIDENT_RESPONSE_ACTION_PROGRAM_STAGE_ID,
+                event: eventId,
+                fields: {
+                    enrollment: true,
+                    dataValues: {
+                        dataElement: true,
+                        value: true,
+                    },
+                },
+            })
+        )
+            .flatMap(response => assertOrError(response.instances[0], "Event"))
+            .flatMap(event => {
+                const enrollmentId = event.enrollment;
+                if (!enrollmentId) {
+                    return Future.error(new Error(`Enrollment not found for response action`));
+                }
+
+                const valueCodeMaps = { ...statusCodeMap, ...verificationCodeMap };
+
+                const eventToPost: D2TrackerEvent = {
+                    event: eventId,
+                    program: RTSL_ZEBRA_PROGRAM_ID,
+                    programStage: RTSL_ZEBRA_INCIDENT_RESPONSE_ACTION_PROGRAM_STAGE_ID,
+                    orgUnit: RTSL_ZEBRA_ORG_UNIT_ID,
+                    enrollment: enrollmentId,
+                    occurredAt: new Date().toISOString(),
+                    trackedEntity: diseaseOutbreakId,
+                    status: "ACTIVE",
+                    dataValues: [
+                        {
+                            dataElement:
+                                incidentResponseActionsIds[
+                                    responseAction.type as keyof typeof incidentResponseActionsIds
+                                ],
+                            value: valueCodeMaps[
+                                responseAction.value as keyof typeof valueCodeMaps
+                            ],
+                        },
+                    ],
+                };
+
+                return apiToFuture(
+                    this.api.tracker.post({ importStrategy: "UPDATE" }, { events: [eventToPost] })
+                ).flatMap(saveResponse => {
+                    if (saveResponse.status === "ERROR") {
+                        return Future.error(new Error(`Error saving Incident Response Action`));
+                    } else {
+                        return Future.success(undefined);
+                    }
+                });
+            });
+    }
+
+    private getProgramStageByFormType(formType: string) {
+        switch (formType) {
+            case "incident-action-plan":
+                return RTSL_ZEBRA_INCIDENT_ACTION_PLAN_PROGRAM_STAGE_ID;
+            case "incident-response-action":
+                return RTSL_ZEBRA_INCIDENT_RESPONSE_ACTION_PROGRAM_STAGE_ID;
+            default:
+                throw new Error("Incident Action Form type not supported");
+        }
+    }
+}
diff --git a/src/data/repositories/OptionsD2Repository.ts b/src/data/repositories/OptionsD2Repository.ts
index deaab05c..a0209774 100644
--- a/src/data/repositories/OptionsD2Repository.ts
+++ b/src/data/repositories/OptionsD2Repository.ts
@@ -34,6 +34,8 @@ export class OptionsD2Repository implements OptionsRepository {
     private likelihoodOptions: Map<string, Option> = new Map();
     private consequencesOptions: Map<string, Option> = new Map();
     private lowMediumHighOptions: Map<string, Option> = new Map();
+    private statusOptions: Map<string, Option> = new Map();
+    private verificationOptions: Map<string, Option> = new Map();
 
     getMainSyndrome(optionCode: Code): FutureData<Option> {
         return this.get(optionCode, MAIN_SYNDROME_OPTION_SET_CODE);
@@ -162,6 +164,40 @@ export class OptionsD2Repository implements OptionsRepository {
         });
     }
 
+    // Incident action plan options
+    getIapTypeOptions(): FutureData<Option[]> {
+        return this.getOptionSetByCode("RTSL_ZEB_OS_IAP_TYPE");
+    }
+
+    getPhoecLevelOptions(): FutureData<Option[]> {
+        return this.getOptionSetByCode("RTSL_ZEB_OS_PHOEC_ACT_LEVEL");
+    }
+
+    // Incident response action options
+    getStatusOptions(): FutureData<Option[]> {
+        return this.getOptionSetByCode("RTSL_ZEB_OS_STATUS");
+    }
+
+    getStatusOption(optionCode: Code): FutureData<Option> {
+        if (this.statusOptions.has(optionCode)) {
+            const cachedOption = this.statusOptions.get(optionCode);
+            if (cachedOption) return Future.success(cachedOption);
+        }
+        return this.get(optionCode, "RTSL_ZEB_OS_STATUS");
+    }
+
+    getVerificationOptions(): FutureData<Option[]> {
+        return this.getOptionSetByCode("RTSL_ZEB_OS_VERIFICATION");
+    }
+
+    getVerificationOption(optionCode: Code): FutureData<Option> {
+        if (this.verificationOptions.has(optionCode)) {
+            const cachedOption = this.verificationOptions.get(optionCode);
+            if (cachedOption) return Future.success(cachedOption);
+        }
+        return this.get(optionCode, "RTSL_ZEB_OS_VERIFICATION");
+    }
+
     private getOptionSetByCode(code: string): FutureData<Option[]> {
         return apiToFuture(
             this.api.metadata.get({
diff --git a/src/data/repositories/consts/DiseaseOutbreakConstants.ts b/src/data/repositories/consts/DiseaseOutbreakConstants.ts
index 6478bffa..cc9a8e70 100644
--- a/src/data/repositories/consts/DiseaseOutbreakConstants.ts
+++ b/src/data/repositories/consts/DiseaseOutbreakConstants.ts
@@ -15,6 +15,8 @@ export const RTSL_ZEBRA_RISK_ASSESSMENT_GRADING_PROGRAM_STAGE_ID = "swh2ZukmkDk"
 export const RTSL_ZEBRA_RISK_ASSESSMENT_SUMMARY_PROGRAM_STAGE_ID = "jBjvgjSgf9d";
 export const RTSL_ZEBRA_RISK_ASSESSMENT_QUESTIONNAIRE_PROGRAM_STAGE_ID = "Ltmf2awDAkS";
 export const RTSL_ZEBRA_RISK_ASSESSMENT_QUESTIONNAIRE_CUSTOM_PROGRAM_STAGE_ID = "LpB1gNXEbEV";
+export const RTSL_ZEBRA_INCIDENT_ACTION_PLAN_PROGRAM_STAGE_ID = "FwUxJTqq35X";
+export const RTSL_ZEBRA_INCIDENT_RESPONSE_ACTION_PROGRAM_STAGE_ID = "bxy7o3UOY6T";
 export const RTSL_ZEBRA_INCIDENT_MANAGEMENT_TEAM_BUILDER_PROGRAM_STAGE_ID = "DwEOpUBGgOp";
 
 export const RTSL_ZEBRA_ALERTS_PROGRAM_ID = "MQtbs8UkBxy";
diff --git a/src/data/repositories/consts/IncidentActionConstants.ts b/src/data/repositories/consts/IncidentActionConstants.ts
new file mode 100644
index 00000000..8f7927b4
--- /dev/null
+++ b/src/data/repositories/consts/IncidentActionConstants.ts
@@ -0,0 +1,134 @@
+import {
+    ActionPlanAttrs,
+    ActionPlanIAPType,
+    ActionPlanPhoecLevel,
+} from "../../../domain/entities/incident-action-plan/ActionPlan";
+import {
+    ResponseAction,
+    ResponseActionStatusType,
+    ResponseActionVerificationType,
+} from "../../../domain/entities/incident-action-plan/ResponseAction";
+import { GetValue, Maybe } from "../../../utils/ts-utils";
+
+export const actionPlanConstants = {
+    iapType: "RTSL_ZEB_DET_IAP_TYPE",
+    phoecLevel: "RTSL_ZEB_DET_PHOEC_ACT_LEVEL",
+    criticalInfoRequirements: "RTSL_ZEB_DET_CIR",
+    planningAssumptions: "RTSL_ZEB_DET_PLANNING_ASSUMPTIONS",
+    responseObjectives: "RTSL_ZEB_DET_RESPONSE_OBJECTIVES",
+    responseStrategies: "RTSL_ZEB_DET_RESPONSE_STRATEGIES",
+    expectedResults: "RTSL_ZEB_DET_SECTIONS_OBJECTIVES_EXPECTED_RESULTS",
+    responseActivitiesNarrative: "RTSL_ZEB_DET_RESPONSE_ACTIVITIES_NARRATIVE",
+} as const;
+
+export type ActionPlanCodes = GetValue<typeof actionPlanConstants>;
+
+export type IncidentActionPlanKeyCode =
+    (typeof actionPlanConstants)[keyof typeof actionPlanConstants];
+
+export function isStringInIncidentActionPlanCodes(code: string): code is IncidentActionPlanKeyCode {
+    return (Object.values(actionPlanConstants) as string[]).includes(code);
+}
+
+const iapTypeCodeMap: Record<ActionPlanIAPType, string> = {
+    Initial: "RTSL_ZEB_OS_IAP_TYPE_INITIAL",
+    Update: "RTSL_ZEB_OS_IAP_TYPE_UPDATE",
+    Final: "RTSL_ZEB_OS_IAP_TYPE_FINAL",
+};
+
+export function getIAPTypeByCode(iapTypeCode: string): Maybe<ActionPlanIAPType> {
+    return (Object.keys(iapTypeCodeMap) as ActionPlanIAPType[]).find(
+        key => iapTypeCodeMap[key] === iapTypeCode
+    );
+}
+
+const phoecLevelCodeMap: Record<ActionPlanPhoecLevel, string> = {
+    Response: "RTSL_ZEB_OS_PHOEC_ACT_LEVEL_RESPONSE",
+    Watch: "RTSL_ZEB_OS_PHOEC_ACT_LEVEL_WATCH",
+    Alert: "RTSL_ZEB_OS_PHOEC_ACT_LEVEL_ALERT",
+};
+
+export function getPhoecLevelByCode(phoecLevelCode: string): ActionPlanPhoecLevel | undefined {
+    return (Object.keys(phoecLevelCodeMap) as ActionPlanPhoecLevel[]).find(
+        key => phoecLevelCodeMap[key] === phoecLevelCode
+    );
+}
+
+export const responseActionConstants = {
+    mainTask: "RTSL_ZEB_DET_MAIN_TASK",
+    subActivities: "RTSL_ZEB_DET_SUB_ACTIVITIES",
+    subPillar: "RTSL_ZEB_DET_SUB_PILLAR",
+    searchAssignRO: "RTSL_ZEB_DET_SEARCH_ASSIGN_RO",
+    dueDate: "RTSL_ZEB_DET_DUE_DATE",
+    timeLine: "RTSL_ZEB_DET_TIMELINE",
+    status: "RTSL_ZEB_DET_STATUS",
+    verification: "RTSL_ZEB_DET_VERIFICATION",
+} as const;
+
+export type ResponseActionCodes = GetValue<typeof responseActionConstants>;
+
+export type IncidentResponseActionKeyCode =
+    (typeof responseActionConstants)[keyof typeof responseActionConstants];
+
+export function isStringInIncidentResponseActionCodes(
+    code: string
+): code is IncidentResponseActionKeyCode {
+    return (Object.values(responseActionConstants) as string[]).includes(code);
+}
+
+export const statusCodeMap: Record<ResponseActionStatusType, string> = {
+    "Not done": "RTSL_ZEB_OS_STATUS_NOT_DONE",
+    Pending: "RTSL_ZEB_OS_STATUS_PENDING",
+    "In Progress": "RTSL_ZEB_OS_STATUS_IN_PROGRESS",
+    Complete: "RTSL_ZEB_OS_STATUS_COMPLETE",
+} as const;
+
+export function getStatusTypeByCode(iapTypeCode: string): Maybe<ResponseActionStatusType> {
+    return (Object.keys(statusCodeMap) as ResponseActionStatusType[]).find(
+        key => statusCodeMap[key] === iapTypeCode
+    );
+}
+
+export const verificationCodeMap: Record<ResponseActionVerificationType, string> = {
+    Verified: "RTSL_ZEB_OS_VERIFICATION_VERIFIED",
+    Unverified: "RTSL_ZEB_OS_VERIFICATION_UNVERIFIED",
+};
+
+export function getVerificationTypeByCode(
+    iapTypeCode: string
+): Maybe<ResponseActionVerificationType> {
+    return (Object.keys(verificationCodeMap) as ResponseActionVerificationType[]).find(
+        key => verificationCodeMap[key] === iapTypeCode
+    );
+}
+
+export function getValueFromIncidentActionPlan(
+    incidentActionPlan: ActionPlanAttrs
+): Record<ActionPlanCodes, string> {
+    return {
+        RTSL_ZEB_DET_IAP_TYPE: incidentActionPlan.iapType || "",
+        RTSL_ZEB_DET_PHOEC_ACT_LEVEL: incidentActionPlan.phoecLevel || "",
+        RTSL_ZEB_DET_CIR: incidentActionPlan.criticalInfoRequirements || "",
+        RTSL_ZEB_DET_PLANNING_ASSUMPTIONS: incidentActionPlan.planningAssumptions || "",
+        RTSL_ZEB_DET_RESPONSE_OBJECTIVES: incidentActionPlan.responseObjectives || "",
+        RTSL_ZEB_DET_RESPONSE_STRATEGIES: incidentActionPlan.responseStrategies || "",
+        RTSL_ZEB_DET_SECTIONS_OBJECTIVES_EXPECTED_RESULTS: incidentActionPlan.expectedResults || "",
+        RTSL_ZEB_DET_RESPONSE_ACTIVITIES_NARRATIVE:
+            incidentActionPlan.responseActivitiesNarrative || "",
+    };
+}
+
+export function getValueFromIncidentResponseAction(
+    incidentResponseAction: ResponseAction
+): Record<ResponseActionCodes, string> {
+    return {
+        RTSL_ZEB_DET_MAIN_TASK: incidentResponseAction.mainTask || "",
+        RTSL_ZEB_DET_SUB_ACTIVITIES: incidentResponseAction.subActivities || "",
+        RTSL_ZEB_DET_SUB_PILLAR: incidentResponseAction.subPillar || "",
+        RTSL_ZEB_DET_SEARCH_ASSIGN_RO: incidentResponseAction.searchAssignRO?.username || "",
+        RTSL_ZEB_DET_DUE_DATE: incidentResponseAction.dueDate.toISOString(),
+        RTSL_ZEB_DET_TIMELINE: incidentResponseAction.timeLine || "",
+        RTSL_ZEB_DET_STATUS: incidentResponseAction.status,
+        RTSL_ZEB_DET_VERIFICATION: incidentResponseAction.verification,
+    };
+}
diff --git a/src/data/repositories/test/IncidentActionTestRepository.ts b/src/data/repositories/test/IncidentActionTestRepository.ts
new file mode 100644
index 00000000..77cab7f7
--- /dev/null
+++ b/src/data/repositories/test/IncidentActionTestRepository.ts
@@ -0,0 +1,31 @@
+import { Id } from "../../../domain/entities/Ref";
+import {
+    IncidentActionRepository,
+    UpdateIncidentResponseActionOptions,
+} from "../../../domain/repositories/IncidentActionRepository";
+import { Maybe } from "../../../utils/ts-utils";
+import { FutureData } from "../../api-futures";
+import {
+    IncidentActionPlanDataValues,
+    IncidentResponseActionDataValues,
+} from "../IncidentActionD2Repository";
+
+export class IncidentActionTestRepository implements IncidentActionRepository {
+    getIncidentActionPlan(_diseaseOutbreakId: Id): FutureData<Maybe<IncidentActionPlanDataValues>> {
+        throw new Error("Method not implemented.");
+    }
+
+    getIncidentResponseActions(
+        _diseaseOutbreakId: Id
+    ): FutureData<Maybe<IncidentResponseActionDataValues[]>> {
+        throw new Error("Method not implemented.");
+    }
+
+    saveIncidentAction(_formData: any, _diseaseOutbreakId: Id): FutureData<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    updateIncidentResponseAction(_options: UpdateIncidentResponseActionOptions): FutureData<void> {
+        throw new Error("Method not implemented.");
+    }
+}
diff --git a/src/data/repositories/test/OptionsTestRepository.ts b/src/data/repositories/test/OptionsTestRepository.ts
index ae407d7a..ef3fef1f 100644
--- a/src/data/repositories/test/OptionsTestRepository.ts
+++ b/src/data/repositories/test/OptionsTestRepository.ts
@@ -109,5 +109,31 @@ export class OptionsTestRepository implements OptionsRepository {
         return Future.success([{ id: "1", name: "Test Incident Status" }]);
     }
 
+    // Incident action plan options
+    getIapTypeOptions(): FutureData<Option[]> {
+        return Future.success([{ id: "1", name: "Test IAP Type" }]);
+    }
+
+    getPhoecLevelOptions(): FutureData<Option[]> {
+        return Future.success([{ id: "1", name: "Test PHOEC Level" }]);
+    }
+
+    // Incident response action options
+    getStatusOptions(): FutureData<Option[]> {
+        return Future.success([{ id: "1", name: "Test Status" }]);
+    }
+
+    getStatusOption(_optionCode: Code): FutureData<Option> {
+        throw new Error("Method not implemented.");
+    }
+
+    getVerificationOptions(): FutureData<Option[]> {
+        return Future.success([{ id: "1", name: "Test Verification" }]);
+    }
+
+    getVerificationOption(_optionCode: Code): FutureData<Option> {
+        throw new Error("Method not implemented.");
+    }
+
     //Risk Grading Options
 }
diff --git a/src/data/repositories/utils/IncidentActionMapper.ts b/src/data/repositories/utils/IncidentActionMapper.ts
new file mode 100644
index 00000000..6da7f536
--- /dev/null
+++ b/src/data/repositories/utils/IncidentActionMapper.ts
@@ -0,0 +1,233 @@
+import { D2TrackerEvent, DataValue } from "@eyeseetea/d2-api/api/trackerEvents";
+import {
+    IncidentActionPlanDataValues,
+    incidentActionPlanIds,
+    IncidentResponseActionDataValues,
+    incidentResponseActionsIds,
+} from "../IncidentActionD2Repository";
+import { Id } from "../../../domain/entities/Ref";
+import { Maybe } from "../../../utils/ts-utils";
+import {
+    ActionPlanFormData,
+    ResponseActionFormData,
+} from "../../../domain/entities/ConfigurableForm";
+import { D2ProgramStageDataElementsMetadata } from "./RiskAssessmentMapper";
+import { ActionPlanAttrs } from "../../../domain/entities/incident-action-plan/ActionPlan";
+import {
+    ActionPlanCodes,
+    getValueFromIncidentActionPlan,
+    getValueFromIncidentResponseAction,
+    IncidentActionPlanKeyCode,
+    IncidentResponseActionKeyCode,
+    isStringInIncidentActionPlanCodes,
+    isStringInIncidentResponseActionCodes,
+    ResponseActionCodes,
+} from "../consts/IncidentActionConstants";
+import { RTSL_ZEBRA_ORG_UNIT_ID, RTSL_ZEBRA_PROGRAM_ID } from "../consts/DiseaseOutbreakConstants";
+import {
+    ResponseAction,
+    Status,
+    Verification,
+} from "../../../domain/entities/incident-action-plan/ResponseAction";
+
+export function mapDataElementsToIncidentActionPlan(
+    id: Id,
+    dataValues: DataValue[]
+): IncidentActionPlanDataValues {
+    const iapType = getValueById(dataValues, incidentActionPlanIds.iapType);
+    const phoecLevel = getValueById(dataValues, incidentActionPlanIds.phoecLevel);
+    const criticalInfoRequirements = getValueById(
+        dataValues,
+        incidentActionPlanIds.criticalInfoRequirements
+    );
+    const planningAssumptions = getValueById(dataValues, incidentActionPlanIds.planningAssumptions);
+    const responseObjectives = getValueById(dataValues, incidentActionPlanIds.responseObjectives);
+    const responseStrategies = getValueById(dataValues, incidentActionPlanIds.responseStrategies);
+    const expectedResults = getValueById(dataValues, incidentActionPlanIds.expectedResults);
+    const responseActivitiesNarrative = getValueById(
+        dataValues,
+        incidentActionPlanIds.responseActivitiesNarrative
+    );
+
+    const incidentActionPlan: IncidentActionPlanDataValues = {
+        id: id,
+        iapType: iapType,
+        phoecLevel: phoecLevel,
+        criticalInfoRequirements: criticalInfoRequirements,
+        planningAssumptions: planningAssumptions,
+        responseObjectives: responseObjectives,
+        responseStrategies: responseStrategies,
+        expectedResults: expectedResults,
+        responseActivitiesNarrative: responseActivitiesNarrative,
+    };
+
+    return incidentActionPlan;
+}
+
+export function mapDataElementsToIncidentResponseActions(
+    instances: D2TrackerEvent[]
+): IncidentResponseActionDataValues[] {
+    const incidentResponseActions: IncidentResponseActionDataValues[] = instances.map(instance => {
+        const { event, dataValues } = instance;
+
+        const mainTask = getValueById(dataValues, incidentResponseActionsIds.mainTask);
+        const subActivities = getValueById(dataValues, incidentResponseActionsIds.subActivities);
+        const subPillar = getValueById(dataValues, incidentResponseActionsIds.subPillar);
+        const searchAssignRO = getValueById(dataValues, incidentResponseActionsIds.searchAssignRO);
+        const dueDate = getValueById(dataValues, incidentResponseActionsIds.dueDate);
+        const timeLine = getValueById(dataValues, incidentResponseActionsIds.timeLine);
+        const status = getValueById(dataValues, incidentResponseActionsIds.status) as Status;
+        const verification = getValueById(
+            dataValues,
+            incidentResponseActionsIds.verification
+        ) as Verification;
+
+        return {
+            id: event,
+            mainTask,
+            subActivities,
+            subPillar,
+            searchAssignRO,
+            dueDate,
+            timeLine,
+            status,
+            verification,
+        };
+    });
+
+    return incidentResponseActions;
+}
+
+export function mapIncidentActionToDataElements(
+    formData: ActionPlanFormData | ResponseActionFormData,
+    programStageId: Id,
+    teiId: Id,
+    enrollmentId: Id,
+    programStageDataElementsMetadata: D2ProgramStageDataElementsMetadata[]
+) {
+    if (!formData.entity) throw new Error("No form data found");
+
+    switch (formData.type) {
+        case "incident-action-plan":
+            return mapIncidentActionPlanToDataElements(
+                programStageId,
+                teiId,
+                enrollmentId,
+                formData.entity,
+                programStageDataElementsMetadata
+            );
+        case "incident-response-action":
+            return mapIncidentResponseActionToDataElements(
+                programStageId,
+                teiId,
+                enrollmentId,
+                formData.entity,
+                programStageDataElementsMetadata
+            );
+        default:
+            throw new Error("Form type not supported");
+    }
+}
+
+function mapIncidentActionPlanToDataElements(
+    programStageId: Id,
+    teiId: Id,
+    enrollmentId: Id,
+    incidentActionPlan: ActionPlanAttrs,
+    programStageDataElementsMetadata: D2ProgramStageDataElementsMetadata[]
+): D2TrackerEvent {
+    const dataElementValues: Record<ActionPlanCodes, string> =
+        getValueFromIncidentActionPlan(incidentActionPlan);
+
+    const dataValues: DataValue[] = programStageDataElementsMetadata.map(programStage => {
+        if (!isStringInIncidentActionPlanCodes(programStage.dataElement.code)) {
+            throw new Error(
+                `DataElement code ${programStage.dataElement.code} not found in Incident Action Plan Codes`
+            );
+        }
+        const typedCode: IncidentActionPlanKeyCode = programStage.dataElement.code;
+        return getPopulatedDataElement(programStage.dataElement.id, dataElementValues[typedCode]);
+    });
+
+    return getIncidentActionTrackerEvent(
+        programStageId,
+        incidentActionPlan.id,
+        enrollmentId,
+        dataValues,
+        teiId
+    );
+}
+
+export function mapIncidentResponseActionToDataElements(
+    programStageId: Id,
+    teiId: Id,
+    enrollmentId: Id,
+    incidentResponseActions: ResponseAction[],
+    programStageDataElementsMetadata: D2ProgramStageDataElementsMetadata[]
+): D2TrackerEvent[] {
+    return incidentResponseActions.map(incidentResponseAction => {
+        const dataElementValues: Record<ResponseActionCodes, string> =
+            getValueFromIncidentResponseAction(incidentResponseAction);
+
+        const dataValues: DataValue[] = programStageDataElementsMetadata.map(programStage => {
+            if (!isStringInIncidentResponseActionCodes(programStage.dataElement.code)) {
+                throw new Error(
+                    `DataElement code ${programStage.dataElement.code} not found in Incident Action Plan Codes`
+                );
+            }
+            const typedCode: IncidentResponseActionKeyCode = programStage.dataElement.code;
+
+            return getPopulatedDataElement(
+                programStage.dataElement.id,
+                dataElementValues[typedCode]
+            );
+        });
+
+        return getIncidentActionTrackerEvent(
+            programStageId,
+            incidentResponseAction.id,
+            enrollmentId,
+            dataValues,
+            teiId
+        );
+    });
+}
+
+function getPopulatedDataElement(dataElement: Id, value: Maybe<string>): DataValue {
+    const populatedDataElement: DataValue = {
+        dataElement: dataElement,
+        value: value ?? "",
+        updatedAt: new Date().toISOString(),
+        storedBy: "",
+        createdAt: new Date().toISOString(),
+        providedElsewhere: false,
+    };
+
+    return populatedDataElement;
+}
+
+function getIncidentActionTrackerEvent(
+    programStageId: Id,
+    id: Maybe<Id>,
+    enrollmentId: Id,
+    dataValues: DataValue[],
+    teiId: Id
+): D2TrackerEvent {
+    const d2IncidentAction: D2TrackerEvent = {
+        event: id ?? "",
+        status: "ACTIVE",
+        program: RTSL_ZEBRA_PROGRAM_ID,
+        programStage: programStageId,
+        enrollment: enrollmentId,
+        orgUnit: RTSL_ZEBRA_ORG_UNIT_ID,
+        occurredAt: new Date().toISOString(),
+        dataValues: dataValues,
+        trackedEntity: teiId,
+    };
+
+    return d2IncidentAction;
+}
+
+function getValueById(dataValues: DataValue[], dataElement: string): Maybe<string> {
+    return dataValues.find(dataValue => dataValue.dataElement === dataElement)?.value;
+}
diff --git a/src/data/repositories/utils/RiskAssessmentMapper.ts b/src/data/repositories/utils/RiskAssessmentMapper.ts
index bb13bf90..eb4a2e6e 100644
--- a/src/data/repositories/utils/RiskAssessmentMapper.ts
+++ b/src/data/repositories/utils/RiskAssessmentMapper.ts
@@ -45,7 +45,7 @@ import {
 import { RiskAssessmentQuestionnaire } from "../../../domain/entities/risk-assessment/RiskAssessmentQuestionnaire";
 import { getPopulatedDataElement, getValueById } from "./helpers";
 
-type D2ProgramStageDataElementsMetadata = {
+export type D2ProgramStageDataElementsMetadata = {
     dataElement: SelectedPick<
         D2DataElementSchema,
         {
diff --git a/src/domain/entities/ConfigurableForm.ts b/src/domain/entities/ConfigurableForm.ts
index 0649bdba..2434d344 100644
--- a/src/domain/entities/ConfigurableForm.ts
+++ b/src/domain/entities/ConfigurableForm.ts
@@ -10,6 +10,8 @@ import { FormType } from "../../webapp/pages/form-page/FormPage";
 import { RiskAssessmentGrading } from "./risk-assessment/RiskAssessmentGrading";
 import { RiskAssessmentSummary } from "./risk-assessment/RiskAssessmentSummary";
 import { RiskAssessmentQuestionnaire } from "./risk-assessment/RiskAssessmentQuestionnaire";
+import { ActionPlanAttrs } from "./incident-action-plan/ActionPlan";
+import { ResponseAction } from "./incident-action-plan/ResponseAction";
 import { IncidentManagementTeam } from "./incident-management-team/IncidentManagementTeam";
 import { Role } from "./incident-management-team/Role";
 
@@ -50,6 +52,17 @@ export type RiskAssessmentQuestionnaireOptions = {
     risk: Option[];
 };
 
+export type IncidentActionPlanOptions = {
+    iapType: Option[];
+    phoecLevel: Option[];
+};
+
+export type IncidentResponseActionOptions = {
+    searchAssignRO: TeamMember[];
+    status: Option[];
+    verification: Option[];
+};
+
 export type FormLables = {
     errors: Record<string, string>;
 };
@@ -86,6 +99,20 @@ export type RiskAssessmentQuestionnaireFormData = BaseFormData & {
     options: RiskAssessmentQuestionnaireOptions;
 };
 
+export type ActionPlanFormData = BaseFormData & {
+    type: "incident-action-plan";
+    eventTrackerDetails: DiseaseOutbreakEvent;
+    entity: Maybe<ActionPlanAttrs>;
+    options: IncidentActionPlanOptions;
+};
+
+export type ResponseActionFormData = BaseFormData & {
+    type: "incident-response-action";
+    eventTrackerDetails: DiseaseOutbreakEvent;
+    entity: ResponseAction[];
+    options: IncidentResponseActionOptions;
+};
+
 export type IncidentManagementTeamRoleOptions = {
     roles: Role[];
     teamMembers: TeamMember[];
@@ -106,4 +133,6 @@ export type ConfigurableForm =
     | RiskAssessmentGradingFormData
     | RiskAssessmentSummaryFormData
     | RiskAssessmentQuestionnaireFormData
+    | ActionPlanFormData
+    | ResponseActionFormData
     | IncidentManagementTeamMemberFormData;
diff --git a/src/domain/entities/incident-action-plan/ActionPlan.ts b/src/domain/entities/incident-action-plan/ActionPlan.ts
index 09336e77..64e8fffe 100644
--- a/src/domain/entities/incident-action-plan/ActionPlan.ts
+++ b/src/domain/entities/incident-action-plan/ActionPlan.ts
@@ -1,8 +1,19 @@
-import { Property } from "../Properties";
 import { Struct } from "../generic/Struct";
+import { Id } from "../Ref";
 
-interface ActionPlanAttrs {
-    properties: Property[];
-}
+export type ActionPlanIAPType = "Initial" | "Update" | "Final";
+export type ActionPlanPhoecLevel = "Response" | "Watch" | "Alert";
+
+export type ActionPlanAttrs = {
+    id: Id;
+    iapType: string;
+    phoecLevel: string;
+    criticalInfoRequirements: string;
+    planningAssumptions: string;
+    responseObjectives: string;
+    responseStrategies: string;
+    expectedResults: string;
+    responseActivitiesNarrative: string;
+};
 
 export class ActionPlan extends Struct<ActionPlanAttrs>() {}
diff --git a/src/domain/entities/incident-action-plan/IncidentActionPlan.ts b/src/domain/entities/incident-action-plan/IncidentActionPlan.ts
index 222a8df2..735c0f88 100644
--- a/src/domain/entities/incident-action-plan/IncidentActionPlan.ts
+++ b/src/domain/entities/incident-action-plan/IncidentActionPlan.ts
@@ -1,12 +1,19 @@
 import { ActionPlan } from "./ActionPlan";
-import { Ref } from "../Ref";
+import { Option, Ref } from "../Ref";
 import { Struct } from "../generic/Struct";
 import { ResponseAction } from "./ResponseAction";
+import { Maybe } from "../../../utils/ts-utils";
+
+export type IncidentActionOptions = {
+    status: Option[];
+    verification: Option[];
+};
 
 interface IncidentActionPlanAttrs extends Ref {
     lastUpdated: Date;
-    actionPlan: ActionPlan;
+    actionPlan: Maybe<ActionPlan>;
     responseActions: ResponseAction[];
+    incidentActionOptions: IncidentActionOptions;
 }
 
 export class IncidentActionPlan extends Struct<IncidentActionPlanAttrs>() {}
diff --git a/src/domain/entities/incident-action-plan/ResponseAction.ts b/src/domain/entities/incident-action-plan/ResponseAction.ts
index 1d2c268c..2c32d2a8 100644
--- a/src/domain/entities/incident-action-plan/ResponseAction.ts
+++ b/src/domain/entities/incident-action-plan/ResponseAction.ts
@@ -1,22 +1,33 @@
-import { CodedNamedRef } from "../Ref";
+import { Maybe } from "../../../utils/ts-utils";
+import { Id } from "../Ref";
 import { Struct } from "../generic/Struct";
 import { TeamMember } from "../incident-management-team/TeamMember";
 
-type ResponseActionStatusType = "NotDone" | "Pending" | "InProgress" | "Complete";
-type ResponseActionVerificationType = "Verified" | "Unverified";
-type MainTask = CodedNamedRef;
-type SubPillar = CodedNamedRef;
-type TimeLine = CodedNamedRef;
+export type ResponseActionStatusType = "Not done" | "Pending" | "In Progress" | "Complete";
+export type ResponseActionVerificationType = "Verified" | "Unverified";
+
+export enum Status {
+    RTSL_ZEB_OS_STATUS_NOT_DONE = "RTSL_ZEB_OS_STATUS_NOT_DONE",
+    RTSL_ZEB_OS_STATUS_PENDING = "RTSL_ZEB_OS_STATUS_PENDING",
+    RTSL_ZEB_OS_STATUS_IN_PROGRESS = "RTSL_ZEB_OS_STATUS_IN_PROGRESS",
+    RTSL_ZEB_OS_STATUS_COMPLETE = "RTSL_ZEB_OS_STATUS_COMPLETE",
+}
+
+export enum Verification {
+    RTSL_ZEB_OS_VERIFICATION_VERIFIED = "RTSL_ZEB_OS_VERIFICATION_VERIFIED",
+    RTSL_ZEB_OS_VERIFICATION_UNVERIFIED = "RTSL_ZEB_OS_VERIFICATION_UNVERIFIED",
+}
 
 interface ResponseActionAttrs {
-    mainTask: MainTask;
+    id: Id;
+    mainTask: string;
     subActivities: string;
-    subPillar: SubPillar;
-    responsibleOfficer: TeamMember;
+    subPillar: string;
+    searchAssignRO: Maybe<TeamMember>;
     dueDate: Date;
-    timeLine: TimeLine;
-    status: ResponseActionStatusType;
-    verification: ResponseActionVerificationType;
+    timeLine: string;
+    status: Status;
+    verification: Verification;
 }
 
 export class ResponseAction extends Struct<ResponseActionAttrs>() {}
diff --git a/src/domain/repositories/IncidentActionRepository.ts b/src/domain/repositories/IncidentActionRepository.ts
new file mode 100644
index 00000000..dce5bc93
--- /dev/null
+++ b/src/domain/repositories/IncidentActionRepository.ts
@@ -0,0 +1,29 @@
+import { FutureData } from "../../data/api-futures";
+import {
+    IncidentActionPlanDataValues,
+    IncidentResponseActionDataValues,
+} from "../../data/repositories/IncidentActionD2Repository";
+import { Maybe } from "../../utils/ts-utils";
+import { ActionPlanFormData, ResponseActionFormData } from "../entities/ConfigurableForm";
+import { Id } from "../entities/Ref";
+
+export interface IncidentActionRepository {
+    getIncidentActionPlan(diseaseOutbreakId: Id): FutureData<Maybe<IncidentActionPlanDataValues>>;
+    getIncidentResponseActions(
+        diseaseOutbreakId: Id
+    ): FutureData<Maybe<IncidentResponseActionDataValues[]>>;
+    saveIncidentAction(
+        formData: ActionPlanFormData | ResponseActionFormData,
+        diseaseOutbreakId: Id
+    ): FutureData<void>;
+    updateIncidentResponseAction(options: UpdateIncidentResponseActionOptions): FutureData<void>;
+}
+
+export type UpdateIncidentResponseActionOptions = {
+    diseaseOutbreakId: Id;
+    eventId: Id;
+    responseAction: {
+        value: string;
+        type: string;
+    };
+};
diff --git a/src/domain/repositories/OptionsRepository.ts b/src/domain/repositories/OptionsRepository.ts
index 7a56a155..4f100025 100644
--- a/src/domain/repositories/OptionsRepository.ts
+++ b/src/domain/repositories/OptionsRepository.ts
@@ -48,4 +48,10 @@ export interface OptionsRepository {
     getLikelihoodOption(optionCode: Code): FutureData<Option>;
     getConsequencesOptions(): FutureData<Option[]>;
     getConsequencesOption(optionCode: Code): FutureData<Option>;
+    getIapTypeOptions(): FutureData<Option[]>;
+    getPhoecLevelOptions(): FutureData<Option[]>;
+    getStatusOptions(): FutureData<Option[]>;
+    getStatusOption(optionCode: Code): FutureData<Option>;
+    getVerificationOptions(): FutureData<Option[]>;
+    getVerificationOption(optionCode: Code): FutureData<Option>;
 }
diff --git a/src/domain/usecases/GetDiseaseOutbreakByIdUseCase.ts b/src/domain/usecases/GetDiseaseOutbreakByIdUseCase.ts
index d108f490..243c8cfa 100644
--- a/src/domain/usecases/GetDiseaseOutbreakByIdUseCase.ts
+++ b/src/domain/usecases/GetDiseaseOutbreakByIdUseCase.ts
@@ -3,12 +3,14 @@ import { DiseaseOutbreakEvent } from "../entities/disease-outbreak-event/Disease
 import { Future } from "../entities/generic/Future";
 import { Id } from "../entities/Ref";
 import { DiseaseOutbreakEventRepository } from "../repositories/DiseaseOutbreakEventRepository";
+import { IncidentActionRepository } from "../repositories/IncidentActionRepository";
 import { IncidentManagementTeamRepository } from "../repositories/IncidentManagementTeamRepository";
 import { OptionsRepository } from "../repositories/OptionsRepository";
 import { OrgUnitRepository } from "../repositories/OrgUnitRepository";
 import { RiskAssessmentRepository } from "../repositories/RiskAssessmentRepository";
 import { RoleRepository } from "../repositories/RoleRepository";
 import { TeamMemberRepository } from "../repositories/TeamMemberRepository";
+import { getIncidentAction } from "./utils/incident-action/GetIncidentActionById";
 import { getIncidentManagementTeamById } from "./utils/incident-management-team/GetIncidentManagementTeamById";
 import { getAll } from "./utils/risk-assessment/GetRiskAssessmentById";
 
@@ -20,6 +22,7 @@ export class GetDiseaseOutbreakByIdUseCase {
             teamMemberRepository: TeamMemberRepository;
             orgUnitRepository: OrgUnitRepository;
             riskAssessmentRepository: RiskAssessmentRepository;
+            incidentActionRepository: IncidentActionRepository;
             incidentManagementTeamRepository: IncidentManagementTeamRepository;
             roleRepository: RoleRepository;
         }
@@ -58,6 +61,12 @@ export class GetDiseaseOutbreakByIdUseCase {
                         this.options.optionsRepository,
                         this.options.teamMemberRepository
                     ),
+                    incidentAction: getIncidentAction(
+                        id,
+                        this.options.incidentActionRepository,
+                        this.options.optionsRepository,
+                        this.options.teamMemberRepository
+                    ),
                     incidentManagementTeam: getIncidentManagementTeamById(id, this.options),
                     roles: this.options.roleRepository.getAll(),
                 }).flatMap(
@@ -68,6 +77,7 @@ export class GetDiseaseOutbreakByIdUseCase {
                         areasAffectedProvinces,
                         areasAffectedDistricts,
                         riskAssessment,
+                        incidentAction,
                         incidentManagementTeam,
                         roles,
                     }) => {
@@ -85,7 +95,7 @@ export class GetDiseaseOutbreakByIdUseCase {
                                         areasAffectedDistricts: areasAffectedDistricts,
                                         incidentManager: incidentManager,
                                         riskAssessment: riskAssessment,
-                                        incidentActionPlan: undefined, //TO DO : FIXME populate once incidentActionPlan repo is implemented
+                                        incidentActionPlan: incidentAction,
                                         incidentManagementTeam: incidentManagementTeam,
                                     });
                                 return Future.success(diseaseOutbreakEvent);
diff --git a/src/domain/usecases/GetEntityWithOptionsUseCase.ts b/src/domain/usecases/GetEntityWithOptionsUseCase.ts
index eec1f885..5eef23b3 100644
--- a/src/domain/usecases/GetEntityWithOptionsUseCase.ts
+++ b/src/domain/usecases/GetEntityWithOptionsUseCase.ts
@@ -6,11 +6,16 @@ import { DiseaseOutbreakEvent } from "../entities/disease-outbreak-event/Disease
 import { Future } from "../entities/generic/Future";
 import { Id } from "../entities/Ref";
 import { DiseaseOutbreakEventRepository } from "../repositories/DiseaseOutbreakEventRepository";
+import { IncidentActionRepository } from "../repositories/IncidentActionRepository";
 import { IncidentManagementTeamRepository } from "../repositories/IncidentManagementTeamRepository";
 import { OptionsRepository } from "../repositories/OptionsRepository";
 import { RoleRepository } from "../repositories/RoleRepository";
 import { TeamMemberRepository } from "../repositories/TeamMemberRepository";
 import { getDiseaseOutbreakWithEventOptions } from "./utils/disease-outbreak/GetDiseaseOutbreakWithOptions";
+import {
+    getIncidentActionPlanWithOptions,
+    getIncidentResponseActionWithOptions,
+} from "./utils/incident-action/GetIncidentActionPlanWithOptions";
 import { getIncidentManagementTeamWithOptions } from "./utils/incident-management-team/GetIncidentManagementTeamWithOptions";
 import {
     getRiskAssessmentGradingWithOptions,
@@ -25,6 +30,7 @@ export class GetEntityWithOptionsUseCase {
             optionsRepository: OptionsRepository;
             roleRepository: RoleRepository;
             teamMemberRepository: TeamMemberRepository;
+            incidentActionRepository: IncidentActionRepository;
             incidentManagementTeamRepository: IncidentManagementTeamRepository;
         }
     ) {}
@@ -65,6 +71,27 @@ export class GetEntityWithOptionsUseCase {
                     eventTrackerDetails,
                     this.options.optionsRepository
                 );
+            case "incident-action-plan":
+                if (!eventTrackerDetails)
+                    return Future.error(
+                        new Error("Disease outbreak id is required for incident action plan")
+                    );
+
+                return getIncidentActionPlanWithOptions(
+                    eventTrackerDetails,
+                    this.options.optionsRepository
+                );
+            case "incident-response-action":
+                if (!eventTrackerDetails)
+                    return Future.error(
+                        new Error("Disease outbreak id is required for incident action plan")
+                    );
+
+                return getIncidentResponseActionWithOptions(
+                    eventTrackerDetails,
+                    this.options.optionsRepository,
+                    this.options.teamMemberRepository
+                );
 
             case "incident-management-team-member-assignment":
                 if (!eventTrackerDetails)
diff --git a/src/domain/usecases/GetIncidentActionByIdUseCase.ts b/src/domain/usecases/GetIncidentActionByIdUseCase.ts
new file mode 100644
index 00000000..06f9ba0b
--- /dev/null
+++ b/src/domain/usecases/GetIncidentActionByIdUseCase.ts
@@ -0,0 +1,27 @@
+import { FutureData } from "../../data/api-futures";
+import { Maybe } from "../../utils/ts-utils";
+import { IncidentActionPlan } from "../entities/incident-action-plan/IncidentActionPlan";
+import { Id } from "../entities/Ref";
+import { IncidentActionRepository } from "../repositories/IncidentActionRepository";
+import { OptionsRepository } from "../repositories/OptionsRepository";
+import { TeamMemberRepository } from "../repositories/TeamMemberRepository";
+import { getIncidentAction } from "./utils/incident-action/GetIncidentActionById";
+
+export class GetIncidentActionByIdUseCase {
+    constructor(
+        private options: {
+            incidentActionRepository: IncidentActionRepository;
+            optionsRepository: OptionsRepository;
+            teamMemberRepository: TeamMemberRepository;
+        }
+    ) {}
+
+    public execute(diseaseOutbreakEventId: Id): FutureData<Maybe<IncidentActionPlan>> {
+        return getIncidentAction(
+            diseaseOutbreakEventId,
+            this.options.incidentActionRepository,
+            this.options.optionsRepository,
+            this.options.teamMemberRepository
+        );
+    }
+}
diff --git a/src/domain/usecases/SaveEntityUseCase.ts b/src/domain/usecases/SaveEntityUseCase.ts
index 1ab20e3d..536602d1 100644
--- a/src/domain/usecases/SaveEntityUseCase.ts
+++ b/src/domain/usecases/SaveEntityUseCase.ts
@@ -5,6 +5,7 @@ import { DiseaseOutbreakEventBaseAttrs } from "../entities/disease-outbreak-even
 import { Future } from "../entities/generic/Future";
 import { Id } from "../entities/Ref";
 import { DiseaseOutbreakEventRepository } from "../repositories/DiseaseOutbreakEventRepository";
+import { IncidentActionRepository } from "../repositories/IncidentActionRepository";
 import { IncidentManagementTeamRepository } from "../repositories/IncidentManagementTeamRepository";
 import { RiskAssessmentRepository } from "../repositories/RiskAssessmentRepository";
 import { TeamMemberRepository } from "../repositories/TeamMemberRepository";
@@ -16,6 +17,7 @@ export class SaveEntityUseCase {
         private options: {
             diseaseOutbreakEventRepository: DiseaseOutbreakEventRepository;
             riskAssessmentRepository: RiskAssessmentRepository;
+            incidentActionRepository: IncidentActionRepository;
             incidentManagementTeamRepository: IncidentManagementTeamRepository;
             teamMemberRepository: TeamMemberRepository;
             roleRepository: RoleRepository;
@@ -43,7 +45,12 @@ export class SaveEntityUseCase {
                     formData,
                     formData.eventTrackerDetails.id
                 );
-
+            case "incident-action-plan":
+            case "incident-response-action":
+                return this.options.incidentActionRepository.saveIncidentAction(
+                    formData,
+                    formData.eventTrackerDetails.id
+                );
             case "incident-management-team-member-assignment": {
                 const isIncidentManager = formData.entity.teamRoles?.find(
                     role => role.roleId === INCIDENT_MANAGER_ROLE
diff --git a/src/domain/usecases/UpdateIncidentResponseActionUseCase.ts b/src/domain/usecases/UpdateIncidentResponseActionUseCase.ts
new file mode 100644
index 00000000..663d94cb
--- /dev/null
+++ b/src/domain/usecases/UpdateIncidentResponseActionUseCase.ts
@@ -0,0 +1,13 @@
+import { FutureData } from "../../data/api-futures";
+import {
+    IncidentActionRepository,
+    UpdateIncidentResponseActionOptions,
+} from "../repositories/IncidentActionRepository";
+
+export class UpdateIncidentResponseActionUseCase {
+    constructor(private options: { incidentActionRepository: IncidentActionRepository }) {}
+
+    public execute(options: UpdateIncidentResponseActionOptions): FutureData<void> {
+        return this.options.incidentActionRepository.updateIncidentResponseAction(options);
+    }
+}
diff --git a/src/domain/usecases/utils/incident-action/GetIncidentActionById.ts b/src/domain/usecases/utils/incident-action/GetIncidentActionById.ts
new file mode 100644
index 00000000..dff75442
--- /dev/null
+++ b/src/domain/usecases/utils/incident-action/GetIncidentActionById.ts
@@ -0,0 +1,104 @@
+import { FutureData } from "../../../../data/api-futures";
+import { Maybe } from "../../../../utils/ts-utils";
+import { Future } from "../../../entities/generic/Future";
+import { ActionPlan } from "../../../entities/incident-action-plan/ActionPlan";
+import { IncidentActionPlan } from "../../../entities/incident-action-plan/IncidentActionPlan";
+import {
+    ResponseAction,
+    Status,
+    Verification,
+} from "../../../entities/incident-action-plan/ResponseAction";
+import { Id } from "../../../entities/Ref";
+import { IncidentActionRepository } from "../../../repositories/IncidentActionRepository";
+import { OptionsRepository } from "../../../repositories/OptionsRepository";
+import { TeamMemberRepository } from "../../../repositories/TeamMemberRepository";
+
+export function getIncidentAction(
+    diseaseOutbreakId: Id,
+    incidentActionRepository: IncidentActionRepository,
+    optionsRepository: OptionsRepository,
+    teamMemberRepository: TeamMemberRepository
+): FutureData<Maybe<IncidentActionPlan>> {
+    return incidentActionRepository
+        .getIncidentActionPlan(diseaseOutbreakId)
+        .flatMap(incidentActionPlan => {
+            const actionPlan = new ActionPlan({
+                id: incidentActionPlan?.id ?? "",
+                iapType: incidentActionPlan?.iapType ?? "",
+                phoecLevel: incidentActionPlan?.phoecLevel ?? "",
+                criticalInfoRequirements: incidentActionPlan?.criticalInfoRequirements ?? "",
+                planningAssumptions: incidentActionPlan?.planningAssumptions ?? "",
+                responseObjectives: incidentActionPlan?.responseObjectives ?? "",
+                responseStrategies: incidentActionPlan?.responseStrategies ?? "",
+                expectedResults: incidentActionPlan?.expectedResults ?? "",
+                responseActivitiesNarrative:
+                    incidentActionPlan?.responseActivitiesNarrative ?? "" ?? "",
+            });
+
+            return incidentActionRepository
+                .getIncidentResponseActions(diseaseOutbreakId)
+                .flatMap(responseActionDataValues => {
+                    return Future.joinObj(
+                        getIncidentResponseActionOptionFutures(
+                            optionsRepository,
+                            teamMemberRepository
+                        )
+                    ).flatMap(responseActionOptions => {
+                        const { searchAssignROOptions, statusOptions, verificationOptions } =
+                            responseActionOptions;
+
+                        const responseActions =
+                            responseActionDataValues?.map(responseActionDataValue => {
+                                const searchAssignRO = searchAssignROOptions.find(
+                                    option =>
+                                        option.username === responseActionDataValue?.searchAssignRO
+                                );
+                                const status = statusOptions.find(
+                                    option => option.id === responseActionDataValue?.status
+                                )?.id as Status;
+                                const verification = verificationOptions.find(
+                                    option => option.id === responseActionDataValue?.verification
+                                )?.id as Verification;
+
+                                return new ResponseAction({
+                                    id: responseActionDataValue?.id ?? "",
+                                    mainTask: responseActionDataValue?.mainTask ?? "",
+                                    subActivities: responseActionDataValue?.subActivities ?? "",
+                                    subPillar: responseActionDataValue?.subPillar ?? "",
+                                    searchAssignRO: searchAssignRO,
+                                    dueDate: responseActionDataValue?.dueDate
+                                        ? new Date(responseActionDataValue.dueDate)
+                                        : new Date(),
+                                    timeLine: responseActionDataValue?.timeLine ?? "",
+                                    status: status,
+                                    verification: verification,
+                                });
+                            }) ?? [];
+
+                        const incidentAction = new IncidentActionPlan({
+                            id: diseaseOutbreakId,
+                            lastUpdated: new Date(),
+                            actionPlan: actionPlan,
+                            responseActions: responseActions,
+                            incidentActionOptions: {
+                                status: statusOptions,
+                                verification: verificationOptions,
+                            },
+                        });
+
+                        return Future.success(incidentAction);
+                    });
+                });
+        });
+}
+
+function getIncidentResponseActionOptionFutures(
+    optionsRepository: OptionsRepository,
+    teamMemberRepository: TeamMemberRepository
+) {
+    return {
+        searchAssignROOptions: teamMemberRepository.getAll(),
+        statusOptions: optionsRepository.getStatusOptions(),
+        verificationOptions: optionsRepository.getVerificationOptions(),
+    };
+}
diff --git a/src/domain/usecases/utils/incident-action/GetIncidentActionPlanWithOptions.ts b/src/domain/usecases/utils/incident-action/GetIncidentActionPlanWithOptions.ts
new file mode 100644
index 00000000..2485af32
--- /dev/null
+++ b/src/domain/usecases/utils/incident-action/GetIncidentActionPlanWithOptions.ts
@@ -0,0 +1,67 @@
+import { FutureData } from "../../../../data/api-futures";
+import { ActionPlanFormData, ResponseActionFormData } from "../../../entities/ConfigurableForm";
+import { DiseaseOutbreakEvent } from "../../../entities/disease-outbreak-event/DiseaseOutbreakEvent";
+import { Future } from "../../../entities/generic/Future";
+import { OptionsRepository } from "../../../repositories/OptionsRepository";
+import { TeamMemberRepository } from "../../../repositories/TeamMemberRepository";
+
+export function getIncidentActionPlanWithOptions(
+    eventTrackerDetails: DiseaseOutbreakEvent,
+    optionsRepository: OptionsRepository
+): FutureData<ActionPlanFormData> {
+    return Future.joinObj({
+        iapTypeOptions: optionsRepository.getIapTypeOptions(),
+        phoecLevelOptions: optionsRepository.getPhoecLevelOptions(),
+    }).flatMap(({ iapTypeOptions, phoecLevelOptions }) => {
+        const incidentActionPlanFormData: ActionPlanFormData = {
+            type: "incident-action-plan",
+            eventTrackerDetails: eventTrackerDetails,
+            entity: eventTrackerDetails.incidentActionPlan?.actionPlan,
+            options: {
+                iapType: iapTypeOptions,
+                phoecLevel: phoecLevelOptions,
+            },
+            // TODO: Get labels from Datastore used in mapEntityToInitialFormState to create initial form state
+            labels: {
+                errors: {
+                    field_is_required: "This field is required",
+                },
+            },
+            rules: [],
+        };
+
+        return Future.success(incidentActionPlanFormData);
+    });
+}
+
+export function getIncidentResponseActionWithOptions(
+    eventTrackerDetails: DiseaseOutbreakEvent,
+    optionsRepository: OptionsRepository,
+    teamMemberRepository: TeamMemberRepository
+): FutureData<ResponseActionFormData> {
+    return Future.joinObj({
+        responsibleOfficers: teamMemberRepository.getAll(),
+        statusOptions: optionsRepository.getStatusOptions(),
+        verificationOptions: optionsRepository.getVerificationOptions(),
+    }).flatMap(({ responsibleOfficers, statusOptions, verificationOptions }) => {
+        const incidentResponseActionData: ResponseActionFormData = {
+            type: "incident-response-action",
+            eventTrackerDetails: eventTrackerDetails,
+            entity: eventTrackerDetails.incidentActionPlan?.responseActions ?? [],
+            options: {
+                searchAssignRO: responsibleOfficers,
+                status: statusOptions,
+                verification: verificationOptions,
+            },
+            // TODO: Get labels from Datastore used in mapEntityToInitialFormState to create initial form state
+            labels: {
+                errors: {
+                    field_is_required: "This field is required",
+                },
+            },
+            rules: [],
+        };
+
+        return Future.success(incidentResponseActionData);
+    });
+}
diff --git a/src/webapp/components/form/FormSection.tsx b/src/webapp/components/form/FormSection.tsx
index 2ddc013e..5e0380ef 100644
--- a/src/webapp/components/form/FormSection.tsx
+++ b/src/webapp/components/form/FormSection.tsx
@@ -61,7 +61,11 @@ export const FormSection: React.FC<FormSectionProps> = React.memo(
                     )}
 
                     {addNewField && handleAddNew && (
-                        <AddNewOption id="" onAddNewOption={handleAddNew} />
+                        <AddNewOption
+                            id=""
+                            label={addNewField.label}
+                            onAddNewOption={handleAddNew}
+                        />
                     )}
 
                     {fields.length && fields.some(f => f.isVisible) ? (
diff --git a/src/webapp/components/form/form-summary/ActionPlanFormSummary.tsx b/src/webapp/components/form/form-summary/ActionPlanFormSummary.tsx
new file mode 100644
index 00000000..e2cf5fae
--- /dev/null
+++ b/src/webapp/components/form/form-summary/ActionPlanFormSummary.tsx
@@ -0,0 +1,81 @@
+import React, { useCallback, useEffect } from "react";
+import styled from "styled-components";
+import i18n from "@eyeseetea/d2-ui-components/locales";
+import { Section } from "../../section/Section";
+import { Box, Button, Typography } from "@material-ui/core";
+import { RouteName, useRoutes } from "../../../hooks/useRoutes";
+import { EditOutlined } from "@material-ui/icons";
+import { Loader } from "../../loader/Loader";
+import { useSnackbar } from "@eyeseetea/d2-ui-components";
+import { Id } from "../../../../domain/entities/Ref";
+import { FormType } from "../../../pages/form-page/FormPage";
+import { IncidentActionFormSummaryData } from "../../../pages/incident-action-plan/useIncidentActionPlan";
+import { Maybe } from "../../../../utils/ts-utils";
+
+type ActionPlanFormSummaryProps = {
+    id: Id;
+    formType: FormType;
+    formSummary: Maybe<IncidentActionFormSummaryData>;
+    summaryError: Maybe<string>;
+};
+
+export const ActionPlanFormSummary: React.FC<ActionPlanFormSummaryProps> = React.memo(props => {
+    const { id, formType, formSummary, summaryError } = props;
+    const { goTo } = useRoutes();
+    const snackbar = useSnackbar();
+
+    useEffect(() => {
+        if (!summaryError) return;
+
+        snackbar.error(summaryError);
+        goTo(RouteName.DASHBOARD);
+    }, [summaryError, snackbar, goTo]);
+
+    const editButton = (
+        <Button
+            variant="outlined"
+            color="secondary"
+            onClick={() => {
+                goTo(RouteName.EDIT_FORM, { formType: formType, id: id }); //TO DO : Change to dynamic formType when available
+            }}
+            startIcon={<EditOutlined />}
+        >
+            {i18n.t("Edit Action Plan")}
+        </Button>
+    );
+
+    const getSummaryColumn = useCallback((index: number, label: string, value: string) => {
+        return (
+            <Typography key={index}>
+                <Box fontWeight="bold">{i18n.t(label)}:</Box> {i18n.t(value)}
+            </Typography>
+        );
+    }, []);
+
+    return formSummary ? (
+        <>
+            <Section
+                title={formSummary.subTitle}
+                hasSeparator={true}
+                headerButton={editButton}
+                titleVariant="secondary"
+            >
+                <SummaryContainer>
+                    {formSummary.summary.map((labelWithValue, index) =>
+                        getSummaryColumn(index, labelWithValue.label, labelWithValue.value)
+                    )}
+                </SummaryContainer>
+            </Section>
+        </>
+    ) : (
+        <Loader />
+    );
+});
+
+const SummaryContainer = styled.div`
+    display: flex;
+    flex-direction: column;
+    margin-top: 0rem;
+    color: ${props => props.theme.palette.text.hint};
+    gap: 1rem;
+`;
diff --git a/src/webapp/components/layout/side-bar/SideBarContent.tsx b/src/webapp/components/layout/side-bar/SideBarContent.tsx
index 6d1e7fc1..2bc100eb 100644
--- a/src/webapp/components/layout/side-bar/SideBarContent.tsx
+++ b/src/webapp/components/layout/side-bar/SideBarContent.tsx
@@ -3,7 +3,6 @@ import React, { useCallback } from "react";
 import styled from "styled-components";
 import { NavLink } from "react-router-dom";
 import { AddCircleOutline } from "@material-ui/icons";
-
 import i18n from "../../../../utils/i18n";
 import { Button } from "../../button/Button";
 import { RouteName, routes, useRoutes } from "../../../hooks/useRoutes";
diff --git a/src/webapp/hooks/useRoutes.ts b/src/webapp/hooks/useRoutes.ts
index 2ea8c057..4f92a630 100644
--- a/src/webapp/hooks/useRoutes.ts
+++ b/src/webapp/hooks/useRoutes.ts
@@ -19,6 +19,8 @@ const formTypes = [
     "risk-assessment-grading",
     "risk-assessment-summary",
     "risk-assessment-questionnaire",
+    "incident-action-plan",
+    "incident-response-action",
     "incident-management-team-member-assignment",
 ] as const satisfies FormType[];
 
diff --git a/src/webapp/pages/form-page/FormPage.tsx b/src/webapp/pages/form-page/FormPage.tsx
index 881cc25a..3d0ad125 100644
--- a/src/webapp/pages/form-page/FormPage.tsx
+++ b/src/webapp/pages/form-page/FormPage.tsx
@@ -12,6 +12,8 @@ export type FormType =
     | "risk-assessment-grading"
     | "risk-assessment-questionnaire"
     | "risk-assessment-summary"
+    | "incident-action-plan"
+    | "incident-response-action"
     | "incident-management-team-member-assignment";
 
 export const FormPage: React.FC = React.memo(() => {
diff --git a/src/webapp/pages/form-page/disease-outbreak-event/utils/updateDiseaseOutbreakEventFormState.ts b/src/webapp/pages/form-page/disease-outbreak-event/utils/updateDiseaseOutbreakEventFormState.ts
index 67783f96..4573a8bc 100644
--- a/src/webapp/pages/form-page/disease-outbreak-event/utils/updateDiseaseOutbreakEventFormState.ts
+++ b/src/webapp/pages/form-page/disease-outbreak-event/utils/updateDiseaseOutbreakEventFormState.ts
@@ -63,6 +63,10 @@ function validateFormState(
             break;
         case "risk-assessment-questionnaire":
             break;
+        case "incident-action-plan":
+            break;
+        case "incident-response-action":
+            break;
         case "incident-management-team-member-assignment":
             break;
     }
diff --git a/src/webapp/pages/form-page/incident-action/mapIncidentActionToInitialFormState.ts b/src/webapp/pages/form-page/incident-action/mapIncidentActionToInitialFormState.ts
new file mode 100644
index 00000000..8166e870
--- /dev/null
+++ b/src/webapp/pages/form-page/incident-action/mapIncidentActionToInitialFormState.ts
@@ -0,0 +1,414 @@
+import {
+    actionPlanConstants,
+    responseActionConstants,
+} from "../../../../data/repositories/consts/IncidentActionConstants";
+import {
+    ActionPlanFormData,
+    ResponseActionFormData,
+} from "../../../../domain/entities/ConfigurableForm";
+import { ResponseAction } from "../../../../domain/entities/incident-action-plan/ResponseAction";
+import { Maybe } from "../../../../utils/ts-utils";
+import { FormSectionState } from "../../../components/form/FormSectionsState";
+import { FormState } from "../../../components/form/FormState";
+import { Option as UIOption } from "../../../components/utils/option";
+import { mapToPresentationOptions } from "../mapEntityToFormState";
+
+type ActionPlanSectionKeys =
+    | "iapType"
+    | "phoecLevel"
+    | "criticalInfoRequirements"
+    | "planningAssumptions"
+    | "responseObjectives"
+    | "responseStrategies"
+    | "expectedResults"
+    | "responseActivitiesNarrative";
+
+export function getAnotherResponseActionSection(): FormSectionState {
+    return {
+        id: "addNewResponseActionSection",
+        isVisible: true,
+        fields: [],
+        addNewField: {
+            id: "addNewResponseAction",
+            isVisible: true,
+            errors: [],
+            type: "addNew",
+            value: null,
+            label: "Add new response action",
+        },
+    };
+}
+
+export function mapIncidentActionPlanToInitialFormState(
+    incidentActionPlanFormData: ActionPlanFormData
+): FormState {
+    const { entity: incidentActionPlan, eventTrackerDetails, options } = incidentActionPlanFormData;
+    const { iapType, phoecLevel } = options;
+
+    const iapTypeOptions: UIOption[] = mapToPresentationOptions(iapType);
+    const phoecLevelOptions: UIOption[] = mapToPresentationOptions(phoecLevel);
+
+    const mainSections: Record<ActionPlanSectionKeys, FormSectionState> = {
+        iapType: {
+            title: "IAP type",
+            id: "iap_type_section",
+            isVisible: true,
+            required: true,
+            direction: "column",
+            fields: [
+                {
+                    id: `${actionPlanConstants.iapType}-section`,
+                    isVisible: true,
+                    errors: [],
+                    type: "select",
+                    multiple: false,
+                    options: iapTypeOptions,
+                    value: incidentActionPlan?.iapType || "",
+                    required: true,
+                },
+            ],
+        },
+        phoecLevel: {
+            title: "PHOEC level",
+            id: "phoec_level_section",
+            isVisible: true,
+            required: true,
+            direction: "column",
+            fields: [
+                {
+                    id: `${actionPlanConstants.phoecLevel}-section`,
+                    isVisible: true,
+                    errors: [],
+                    type: "select",
+                    multiple: false,
+                    options: phoecLevelOptions,
+                    value: incidentActionPlan?.phoecLevel || "",
+                    required: true,
+                },
+            ],
+        },
+        criticalInfoRequirements: {
+            title: "Response mode critical information requirements (CIRs)",
+            id: "critical_info_requirements_section",
+            isVisible: true,
+            required: true,
+            direction: "column",
+            fields: [
+                {
+                    id: `${actionPlanConstants.criticalInfoRequirements}-section`,
+                    isVisible: true,
+                    errors: [],
+                    type: "text",
+                    value: incidentActionPlan?.criticalInfoRequirements || "",
+                    multiline: true,
+                    required: true,
+                },
+            ],
+        },
+        planningAssumptions: {
+            title: "Planning assumptions",
+            id: "planning_assumptions_section",
+            isVisible: true,
+            required: true,
+            direction: "column",
+            fields: [
+                {
+                    id: `${actionPlanConstants.planningAssumptions}-section`,
+                    isVisible: true,
+                    errors: [],
+                    type: "text",
+                    value: incidentActionPlan?.planningAssumptions || "",
+                    multiline: true,
+                    required: true,
+                    helperText:
+                        "Evidence based facts and assumptions in the context of developing the plan.",
+                },
+            ],
+        },
+        responseObjectives: {
+            title: "Response objectives",
+            id: "response_objectives_section",
+            isVisible: true,
+            required: true,
+            direction: "column",
+            fields: [
+                {
+                    id: `${actionPlanConstants.responseObjectives}-section`,
+                    isVisible: true,
+                    errors: [],
+                    type: "text",
+                    value: incidentActionPlan?.responseObjectives || "",
+                    multiline: true,
+                    required: true,
+                    helperText: "SMART: Specific, measurable, achievable, relevant, time-bound",
+                },
+            ],
+        },
+        responseStrategies: {
+            title: "Response strategies",
+            id: "response_strategies_section",
+            isVisible: true,
+            required: true,
+            direction: "column",
+            fields: [
+                {
+                    id: `${actionPlanConstants.responseStrategies}-section`,
+                    isVisible: true,
+                    errors: [],
+                    type: "text",
+                    value: incidentActionPlan?.responseStrategies || "",
+                    multiline: true,
+                    required: true,
+                },
+            ],
+        },
+        expectedResults: {
+            title: "Sections, functional area objectives, expected results",
+            id: "expected_results_section",
+            isVisible: true,
+            direction: "column",
+            fields: [
+                {
+                    id: `${actionPlanConstants.expectedResults}-section`,
+                    isVisible: true,
+                    errors: [],
+                    type: "text",
+                    value: incidentActionPlan?.expectedResults || "",
+                    multiline: true,
+                    helperText: "Clear objectives for functional area",
+                },
+            ],
+        },
+        responseActivitiesNarrative: {
+            title: "Response activities narrative",
+            id: "response_activities_narrative_section",
+            isVisible: true,
+            direction: "column",
+            fields: [
+                {
+                    id: `${actionPlanConstants.responseActivitiesNarrative}-section`,
+                    isVisible: true,
+                    errors: [],
+                    type: "text",
+                    value: incidentActionPlan?.responseActivitiesNarrative || "",
+                    multiline: true,
+                },
+            ],
+        },
+    };
+
+    return {
+        id: eventTrackerDetails.id ?? "",
+        title: "Incident Action Plan",
+        subtitle: eventTrackerDetails.name,
+        titleDescripton: "Step 1:",
+        subtitleDescripton: "Define the action plan",
+        saveButtonLabel: "Save & Continue",
+        isValid: incidentActionPlan ? true : false,
+        sections: [
+            mainSections.iapType,
+            mainSections.phoecLevel,
+            mainSections.criticalInfoRequirements,
+            mainSections.planningAssumptions,
+            mainSections.responseObjectives,
+            mainSections.responseStrategies,
+            mainSections.expectedResults,
+            mainSections.responseActivitiesNarrative,
+        ],
+    };
+}
+
+export function mapIncidentResponseActionToInitialFormState(
+    incidentResponseActionFormData: ResponseActionFormData
+): FormState {
+    const {
+        entity: incidentResponseActions,
+        eventTrackerDetails,
+        options,
+    } = incidentResponseActionFormData;
+
+    const { searchAssignRO, status, verification } = options;
+    const searchAssignROOptions: UIOption[] = mapToPresentationOptions(searchAssignRO);
+    const statusOptions: UIOption[] = mapToPresentationOptions(status);
+    const verificationOptions: UIOption[] = mapToPresentationOptions(verification);
+
+    const initialResponseActionSection = getResponseActionSection({
+        incidentResponseAction: undefined,
+        options: {
+            searchAssignROOptions: searchAssignROOptions,
+            statusOptions: statusOptions,
+            verificationOptions: verificationOptions,
+        },
+        index: 0,
+    });
+
+    const responseActionSections =
+        incidentResponseActions.length !== 0
+            ? incidentResponseActions.map((incidentResponseAction, index) => {
+                  return getResponseActionSection({
+                      incidentResponseAction: incidentResponseAction,
+                      options: {
+                          searchAssignROOptions: searchAssignROOptions,
+                          statusOptions: statusOptions,
+                          verificationOptions: verificationOptions,
+                      },
+                      index: index,
+                  });
+              })
+            : [initialResponseActionSection];
+
+    const addNewResponseActionSection: FormSectionState = getAnotherResponseActionSection();
+
+    return {
+        id: eventTrackerDetails.id ?? "",
+        title: "Incident Action Plan",
+        subtitle: eventTrackerDetails.name,
+        titleDescripton: "Step 2:",
+        subtitleDescripton: "Assign response actions",
+        saveButtonLabel: "Save plan",
+        isValid: incidentResponseActions.length !== 0 ? true : false,
+        sections: [...responseActionSections, addNewResponseActionSection],
+    };
+}
+
+function getResponseActionSection(options: {
+    incidentResponseAction: Maybe<ResponseAction>;
+    options: {
+        searchAssignROOptions: UIOption[];
+        statusOptions: UIOption[];
+        verificationOptions: UIOption[];
+    };
+    index: number;
+}) {
+    const { incidentResponseAction, options: formOptions, index } = options;
+    const { searchAssignROOptions, statusOptions, verificationOptions } = formOptions;
+
+    const responseActionSection: FormSectionState = {
+        title: "",
+        id: `response_action_section_${index}`,
+        isVisible: true,
+        direction: "row",
+        fields: [
+            {
+                id: `${responseActionConstants.mainTask}_${index}`,
+                label: "Main task",
+                isVisible: true,
+                errors: [],
+                value: incidentResponseAction?.mainTask || "",
+                type: "text",
+                required: true,
+                showIsRequired: true,
+                disabled: false,
+            },
+            {
+                id: `${responseActionConstants.subActivities}_${index}`,
+                label: "Sub activities",
+                isVisible: true,
+                errors: [],
+                value: incidentResponseAction?.subActivities || "",
+                type: "text",
+                required: true,
+                showIsRequired: true,
+                disabled: false,
+            },
+            {
+                id: `${responseActionConstants.subPillar}_${index}`,
+                label: "Sub pilar",
+                isVisible: true,
+                errors: [],
+                value: incidentResponseAction?.subPillar || "",
+                type: "text",
+                required: true,
+                showIsRequired: true,
+                disabled: false,
+            },
+            {
+                id: `${responseActionConstants.searchAssignRO}_${index}`,
+                label: "Responsible officer",
+                isVisible: true,
+                errors: [],
+                value: incidentResponseAction?.searchAssignRO?.id || "",
+                type: "select",
+                multiple: false,
+                options: searchAssignROOptions,
+                required: true,
+                showIsRequired: true,
+                disabled: false,
+            },
+            {
+                id: `${responseActionConstants.dueDate}_${index}`,
+                label: "Due date",
+                isVisible: true,
+                errors: [],
+                value: incidentResponseAction?.dueDate
+                    ? new Date(incidentResponseAction?.dueDate)
+                    : new Date(),
+                type: "date",
+                width: "200px",
+                required: true,
+                showIsRequired: true,
+                disabled: false,
+            },
+            {
+                id: `${responseActionConstants.timeLine}_${index}`,
+                label: "Time line",
+                isVisible: true,
+                errors: [],
+                value: incidentResponseAction?.timeLine || "",
+                type: "text",
+                required: true,
+                showIsRequired: true,
+                disabled: false,
+            },
+            {
+                id: `${responseActionConstants.status}_${index}`,
+                label: "Status",
+                isVisible: true,
+                errors: [],
+                value: incidentResponseAction?.status || "",
+                type: "select",
+                multiple: false,
+                options: statusOptions,
+                required: true,
+                showIsRequired: true,
+                disabled: false,
+            },
+            {
+                id: `${responseActionConstants.verification}_${index}`,
+                label: "Verification",
+                isVisible: true,
+                errors: [],
+                value: incidentResponseAction?.verification || "",
+                type: "select",
+                multiple: false,
+                options: verificationOptions,
+                required: true,
+                showIsRequired: true,
+                disabled: false,
+            },
+        ],
+    };
+
+    return responseActionSection;
+}
+
+export function addNewResponseActionSection(sections: FormSectionState[]): FormSectionState {
+    const responseActionSections = sections.filter(
+        section => !section.id.startsWith("addNewResponseActionSection")
+    );
+
+    const newResponseActionSection = getResponseActionSection({
+        incidentResponseAction: undefined,
+        options: {
+            searchAssignROOptions:
+                sections[0]?.fields[3]?.type === "select" ? sections[0].fields[3].options : [],
+            statusOptions:
+                sections[0]?.fields[6]?.type === "select" ? sections[0].fields[6].options : [],
+            verificationOptions:
+                sections[0]?.fields[7]?.type === "select" ? sections[0].fields[7].options : [],
+        },
+        index: responseActionSections.length,
+    });
+
+    return newResponseActionSection;
+}
diff --git a/src/webapp/pages/form-page/mapEntityToFormState.ts b/src/webapp/pages/form-page/mapEntityToFormState.ts
index 76293370..fc9ce2be 100644
--- a/src/webapp/pages/form-page/mapEntityToFormState.ts
+++ b/src/webapp/pages/form-page/mapEntityToFormState.ts
@@ -5,6 +5,10 @@ import { FormState } from "../../components/form/FormState";
 import { User } from "../../components/user-selector/UserSelector";
 import { Option as PresentationOption } from "../../components/utils/option";
 import { mapDiseaseOutbreakEventToInitialFormState } from "./disease-outbreak-event/mapDiseaseOutbreakEventToInitialFormState";
+import {
+    mapIncidentActionPlanToInitialFormState,
+    mapIncidentResponseActionToInitialFormState,
+} from "./incident-action/mapIncidentActionToInitialFormState";
 import { mapIncidentManagementTeamMemberToInitialFormState } from "./incident-management-team-member-assignment/mapIncidentManagementTeamMemberToInitialFormState";
 import {
     mapRiskAssessmentQuestionnaireToInitialFormState,
@@ -25,6 +29,10 @@ export function mapEntityToFormState(
             return mapRiskAssessmentSummaryToInitialFormState(configurableForm);
         case "risk-assessment-questionnaire":
             return mapRiskAssessmentQuestionnaireToInitialFormState(configurableForm);
+        case "incident-action-plan":
+            return mapIncidentActionPlanToInitialFormState(configurableForm);
+        case "incident-response-action":
+            return mapIncidentResponseActionToInitialFormState(configurableForm);
         case "incident-management-team-member-assignment":
             return mapIncidentManagementTeamMemberToInitialFormState(configurableForm);
     }
diff --git a/src/webapp/pages/form-page/mapFormStateToEntityData.ts b/src/webapp/pages/form-page/mapFormStateToEntityData.ts
index 0b04834a..a8643690 100644
--- a/src/webapp/pages/form-page/mapFormStateToEntityData.ts
+++ b/src/webapp/pages/form-page/mapFormStateToEntityData.ts
@@ -17,11 +17,13 @@ import {
 import {
     ConfigurableForm,
     DiseaseOutbreakEventFormData,
+    ActionPlanFormData,
     IncidentManagementTeamMemberFormData,
     RiskAssessmentGradingFormData,
     RiskAssessmentQuestionnaireFormData,
     RiskAssessmentQuestionnaireOptions,
     RiskAssessmentSummaryFormData,
+    ResponseActionFormData,
 } from "../../../domain/entities/ConfigurableForm";
 import { Maybe } from "../../../utils/ts-utils";
 import { RiskAssessmentGrading } from "../../../domain/entities/risk-assessment/RiskAssessmentGrading";
@@ -35,6 +37,16 @@ import {
     RiskAssessmentQuestion,
     RiskAssessmentQuestionnaire,
 } from "../../../domain/entities/risk-assessment/RiskAssessmentQuestionnaire";
+import { ActionPlanAttrs } from "../../../domain/entities/incident-action-plan/ActionPlan";
+import {
+    actionPlanConstants as actionPlanConstants,
+    responseActionConstants,
+} from "../../../data/repositories/consts/IncidentActionConstants";
+import {
+    ResponseAction,
+    Status,
+    Verification,
+} from "../../../domain/entities/incident-action-plan/ResponseAction";
 import { TeamMember } from "../../../domain/entities/incident-management-team/TeamMember";
 import { TEAM_ROLE_FIELD_ID } from "./incident-management-team-member-assignment/mapIncidentManagementTeamMemberToInitialFormState";
 import { incidentManagementTeamBuilderCodesWithoutRoles } from "../../../data/repositories/consts/IncidentManagementTeamBuilderConstants";
@@ -85,6 +97,24 @@ export function mapFormStateToEntityData(
             };
             return riskQuestionnaireForm;
         }
+        case "incident-action-plan": {
+            const actionPlan = mapFormStateToIncidentActionPlan(formState, formData);
+            const actionPlanForm: ActionPlanFormData = {
+                ...formData,
+                entity: actionPlan,
+            };
+
+            return actionPlanForm;
+        }
+        case "incident-response-action": {
+            const responseActions = mapFormStateToIncidentResponseAction(formState, formData);
+            const responseActionForm: ResponseActionFormData = {
+                ...formData,
+                entity: responseActions,
+            };
+
+            return responseActionForm;
+        }
 
         case "incident-management-team-member-assignment": {
             const incidentManagementTeamMember: TeamMember =
@@ -455,6 +485,122 @@ function mapFormStateToRiskAssessmentQuestionnaire(
     return riskAssessmentQuestionnaire;
 }
 
+function mapFormStateToIncidentActionPlan(
+    formState: FormState,
+    formData: ActionPlanFormData
+): ActionPlanAttrs {
+    const allFields: FormFieldState[] = getAllFieldsFromSections(formState.sections);
+
+    const iapType = allFields.find(field => field.id.includes(actionPlanConstants.iapType))
+        ?.value as string;
+
+    const phoecLevel = allFields.find(field => field.id.includes(actionPlanConstants.phoecLevel))
+        ?.value as string;
+
+    const criticalInfoRequirements = allFields.find(field =>
+        field.id.includes(actionPlanConstants.criticalInfoRequirements)
+    )?.value as string;
+
+    const planningAssumptions = allFields.find(field =>
+        field.id.includes(actionPlanConstants.planningAssumptions)
+    )?.value as string;
+
+    const responseObjectives = allFields.find(field =>
+        field.id.includes(actionPlanConstants.responseObjectives)
+    )?.value as string;
+
+    const responseStrategies = allFields.find(field =>
+        field.id.includes(actionPlanConstants.responseStrategies)
+    )?.value as string;
+
+    const expectedResults = allFields.find(field =>
+        field.id.includes(actionPlanConstants.expectedResults)
+    )?.value as string;
+
+    const responseActivitiesNarrative = allFields.find(field =>
+        field.id.includes(actionPlanConstants.responseActivitiesNarrative)
+    )?.value as string;
+
+    const incidentActionPlan: ActionPlanAttrs = {
+        iapType: iapType,
+        phoecLevel: phoecLevel,
+        id: formData.entity?.id ?? "",
+        criticalInfoRequirements: criticalInfoRequirements,
+        planningAssumptions: planningAssumptions,
+        responseObjectives: responseObjectives,
+        responseStrategies: responseStrategies,
+        expectedResults: expectedResults,
+        responseActivitiesNarrative: responseActivitiesNarrative,
+    };
+
+    return incidentActionPlan;
+}
+
+function mapFormStateToIncidentResponseAction(
+    formState: FormState,
+    formData: ResponseActionFormData
+): ResponseAction[] {
+    const allFields: FormFieldState[] = getAllFieldsFromSections(formState.sections);
+
+    const incidentResponseActions: ResponseAction[] = formState.sections
+        .filter(section => !section.id.includes("addNewResponseActionSection"))
+        .map((_, index): ResponseAction => {
+            const mainTask = allFields.find(field =>
+                field.id.includes(`${responseActionConstants.mainTask}_${index}`)
+            )?.value as string;
+            const subActivities = allFields.find(field =>
+                field.id.includes(`${responseActionConstants.subActivities}_${index}`)
+            )?.value as string;
+            const subPillar = allFields.find(field =>
+                field.id.includes(`${responseActionConstants.subPillar}_${index}`)
+            )?.value as string;
+            const dueDate = allFields.find(field =>
+                field.id.includes(`${responseActionConstants.dueDate}_${index}`)
+            )?.value as Date;
+            const timeLine = allFields.find(field =>
+                field.id.includes(`${responseActionConstants.timeLine}_${index}`)
+            )?.value as string;
+
+            const searchAssignROValue = allFields.find(field =>
+                field.id.includes(`${responseActionConstants.searchAssignRO}_${index}`)
+            )?.value as string;
+            const searchAssignRO = formData.options.searchAssignRO.find(
+                option => option.id === searchAssignROValue
+            );
+            if (!searchAssignRO) throw new Error("Responsible officer not found");
+
+            const statusValue = allFields.find(field =>
+                field.id.includes(`${responseActionConstants.status}_${index}`)
+            )?.value as string;
+            const status = formData.options.status.find(option => option.id === statusValue);
+            if (!status) throw new Error("Status not found");
+
+            const verificationValue = allFields.find(field =>
+                field.id.includes(`${responseActionConstants.verification}_${index}`)
+            )?.value as string;
+            const verification = formData.options.verification.find(
+                option => option.id === verificationValue
+            );
+            if (!verification) throw new Error("Verification not found");
+
+            const responseAction = new ResponseAction({
+                id: formData.entity?.[index]?.id ?? "",
+                mainTask: mainTask,
+                subActivities: subActivities,
+                subPillar: subPillar,
+                dueDate: dueDate,
+                timeLine: timeLine,
+                searchAssignRO: searchAssignRO,
+                status: status.id as Status,
+                verification: verification.id as Verification,
+            });
+
+            return responseAction;
+        });
+
+    return incidentResponseActions;
+}
+
 function getRiskAssessmentQuestionsWithOption(
     questionType: "std" | "custom",
     allFields: FormFieldState[],
diff --git a/src/webapp/pages/form-page/useForm.ts b/src/webapp/pages/form-page/useForm.ts
index 0aeca5ee..4de97494 100644
--- a/src/webapp/pages/form-page/useForm.ts
+++ b/src/webapp/pages/form-page/useForm.ts
@@ -16,6 +16,10 @@ import {
     addNewCustomQuestionSection,
     getAnotherOptionSection,
 } from "./risk-assessment/mapRiskAssessmentToInitialFormState";
+import {
+    addNewResponseActionSection,
+    getAnotherResponseActionSection,
+} from "./incident-action/mapIncidentActionToInitialFormState";
 import { DiseaseOutbreakEvent } from "../../../domain/entities/disease-outbreak-event/DiseaseOutbreakEvent";
 
 export type GlobalMessage = {
@@ -99,6 +103,7 @@ export function useForm(formType: FormType, id?: Id): State {
 
     const handleAddNew = useCallback(() => {
         if (formState.kind !== "loaded" || !configurableForm) return;
+
         switch (configurableForm.type) {
             case "risk-assessment-questionnaire": {
                 setFormState(prevState => {
@@ -144,10 +149,52 @@ export function useForm(formType: FormType, id?: Id): State {
                 });
                 break;
             }
+            case "incident-response-action":
+                setFormState(prevState => {
+                    if (prevState.kind === "loaded") {
+                        const otherSections = prevState.data.sections.filter(
+                            section => section.id !== "addNewResponseActionSection"
+                        );
+                        const addAnotherSection = getAnotherResponseActionSection();
+                        const newResponseActionSection = addNewResponseActionSection(
+                            prevState.data.sections
+                        );
+
+                        const updatedData = {
+                            ...prevState.data,
+                            sections: [
+                                ...otherSections,
+                                newResponseActionSection,
+                                addAnotherSection,
+                            ],
+                        };
+
+                        const allNewFields = newResponseActionSection.fields;
+
+                        const updatedAndValidatedData = allNewFields.reduce(
+                            (acc, updatedFields) => {
+                                return updateAndValidateFormState(
+                                    acc,
+                                    updatedFields,
+                                    configurableForm
+                                );
+                            },
+                            updatedData
+                        );
+
+                        return {
+                            kind: "loaded",
+                            data: updatedAndValidatedData,
+                        };
+                    } else {
+                        return prevState;
+                    }
+                });
+                break;
             default:
                 break;
         }
-    }, [configurableForm, formState.kind]);
+    }, [configurableForm, formState]);
 
     const handleFormChange = useCallback(
         (updatedField: FormFieldState) => {
@@ -180,6 +227,7 @@ export function useForm(formType: FormType, id?: Id): State {
             currentUser.username,
             configurableForm
         );
+
         compositionRoot.save.execute(formData).run(
             diseaseOutbreakEventId => {
                 setIsLoading(false);
@@ -233,6 +281,22 @@ export function useForm(formType: FormType, id?: Id): State {
                             type: "success",
                         });
                         break;
+                    case "incident-action-plan":
+                        goTo(RouteName.CREATE_FORM, {
+                            formType: "incident-response-action",
+                        });
+                        setGlobalMessage({
+                            text: i18n.t(`Incident Action Plan saved successfully`),
+                            type: "success",
+                        });
+                        break;
+                    case "incident-response-action":
+                        if (currentEventTracker?.id) goTo(RouteName.INCIDENT_ACTION_PLAN);
+                        setGlobalMessage({
+                            text: i18n.t(`Incident Response Actions saved successfully`),
+                            type: "success",
+                        });
+                        break;
 
                     case "incident-management-team-member-assignment":
                         if (currentEventTracker?.id)
@@ -270,15 +334,20 @@ export function useForm(formType: FormType, id?: Id): State {
                         id: currentEventTracker.id,
                     });
                     break;
+                case "incident-action-plan":
+                case "incident-response-action":
+                    goTo(RouteName.INCIDENT_ACTION_PLAN);
+                    break;
                 default:
                     goTo(RouteName.EVENT_TRACKER, {
                         id: currentEventTracker.id,
                     });
+                    break;
             }
         } else {
             goTo(RouteName.DASHBOARD);
         }
-    }, [currentEventTracker, goTo, formType]);
+    }, [currentEventTracker, formType, goTo]);
 
     return {
         formLabels,
diff --git a/src/webapp/pages/incident-action-plan/IncidentActionNotice.tsx b/src/webapp/pages/incident-action-plan/IncidentActionNotice.tsx
new file mode 100644
index 00000000..49383337
--- /dev/null
+++ b/src/webapp/pages/incident-action-plan/IncidentActionNotice.tsx
@@ -0,0 +1,37 @@
+import React from "react";
+import { NoticeBox } from "../../components/notice-box/NoticeBox";
+import { RouteName, useRoutes } from "../../hooks/useRoutes";
+import i18n from "../../../utils/i18n";
+import { Button } from "@material-ui/core";
+import { EditOutlined } from "@material-ui/icons";
+
+export const IncidentActionNotice: React.FC = React.memo(() => {
+    const { goTo } = useRoutes();
+
+    return (
+        <NoticeBox title={i18n.t("Create an incident action plan")}>
+            <div
+                style={{
+                    display: "flex",
+                    justifyContent: "space-between",
+                    alignItems: "center",
+                }}
+            >
+                <p>{i18n.t("No plan has been created for this incident")}</p>
+
+                <Button
+                    variant="contained"
+                    color="primary"
+                    startIcon={<EditOutlined />}
+                    onClick={() => {
+                        goTo(RouteName.CREATE_FORM, {
+                            formType: "incident-action-plan",
+                        });
+                    }}
+                >
+                    {i18n.t("Create IAP")}
+                </Button>
+            </div>
+        </NoticeBox>
+    );
+});
diff --git a/src/webapp/pages/incident-action-plan/IncidentActionPlanPage.tsx b/src/webapp/pages/incident-action-plan/IncidentActionPlanPage.tsx
index 36728c67..8e5f6b19 100644
--- a/src/webapp/pages/incident-action-plan/IncidentActionPlanPage.tsx
+++ b/src/webapp/pages/incident-action-plan/IncidentActionPlanPage.tsx
@@ -1,13 +1,95 @@
-import React from "react";
-
+import React, { useCallback } from "react";
 import i18n from "../../../utils/i18n";
 import { Layout } from "../../components/layout/Layout";
+import { useCurrentEventTracker } from "../../contexts/current-event-tracker-context";
+import { useIncidentActionPlan } from "./useIncidentActionPlan";
+import { Box, Typography } from "@material-ui/core";
+import { Section } from "../../components/section/Section";
+import styled from "styled-components";
+import { ActionPlanFormSummary } from "../../components/form/form-summary/ActionPlanFormSummary";
+import { IncidentActionNotice } from "./IncidentActionNotice";
+import { Loader } from "../../components/loader/Loader";
+import { ResponseActionTable } from "./ResponseActionTable";
 
 export const IncidentActionPlanPage: React.FC = React.memo(() => {
+    const { getCurrentEventTracker } = useCurrentEventTracker();
+    const currentEventTracker = getCurrentEventTracker();
+    const id = currentEventTracker?.id || "";
+
+    const {
+        actionPlanSummary,
+        formSummary: incidentActionFormSummary,
+        responseActionRows,
+        summaryError,
+        incidentActionExists,
+        responseActionColumns,
+        saveTableOption,
+    } = useIncidentActionPlan(id);
+
+    const getSummaryColumn = useCallback((index: number, label: string, value: string) => {
+        return (
+            <Typography key={index}>
+                <Box fontWeight="bold" display="inline">
+                    {i18n.t(label)}:
+                </Box>{" "}
+                {i18n.t(value)}
+            </Typography>
+        );
+    }, []);
+
     return (
         <Layout
             title={i18n.t("Incident Action Plan")}
-            subtitle={i18n.t("Cholera in NW Province, June 2023")}
-        ></Layout>
+            subtitle={i18n.t(currentEventTracker?.name || "")}
+        >
+            {!actionPlanSummary && responseActionRows.length === 0 && !summaryError && <Loader />}
+            {!incidentActionExists ? (
+                <IncidentActionNotice />
+            ) : (
+                <>
+                    <Section>
+                        <SummaryContainer>
+                            <SummaryColumn>
+                                {incidentActionFormSummary?.map((labelWithValue, index) =>
+                                    getSummaryColumn(
+                                        index,
+                                        labelWithValue.label,
+                                        labelWithValue.value
+                                    )
+                                )}
+                            </SummaryColumn>
+                        </SummaryContainer>
+                    </Section>
+
+                    <ResponseActionTable
+                        responseActionColumns={responseActionColumns}
+                        responseActionRows={responseActionRows}
+                        onChange={saveTableOption}
+                    />
+
+                    <ActionPlanFormSummary
+                        formType="incident-action-plan"
+                        formSummary={actionPlanSummary}
+                        summaryError={summaryError}
+                        id={id}
+                    />
+                </>
+            )}
+        </Layout>
     );
 });
+
+const SummaryContainer = styled.div`
+    display: flex;
+    width: max-content;
+    align-items: center;
+    margin-top: 0rem;
+    margin-bottom: 3rem;
+`;
+
+const SummaryColumn = styled.div`
+    flex: 1;
+    padding-right: 2rem;
+    color: ${props => props.theme.palette.text.hint};
+    min-width: fit-content;
+`;
diff --git a/src/webapp/pages/incident-action-plan/ResponseActionTable.tsx b/src/webapp/pages/incident-action-plan/ResponseActionTable.tsx
new file mode 100644
index 00000000..3162255a
--- /dev/null
+++ b/src/webapp/pages/incident-action-plan/ResponseActionTable.tsx
@@ -0,0 +1,62 @@
+import React from "react";
+import i18n from "../../../utils/i18n";
+import { RouteName, useRoutes } from "../../hooks/useRoutes";
+import { Section } from "../../components/section/Section";
+import { BasicTable, TableColumn, TableRowType } from "../../components/table/BasicTable";
+import { Box, Button } from "@material-ui/core";
+import { AddCircleOutline, EditOutlined } from "@material-ui/icons";
+import { Maybe } from "../../../utils/ts-utils";
+
+type ResponseActionTableProps = {
+    onChange: (value: Maybe<string>, rowIndex: number, column: TableColumn["value"]) => void;
+    responseActionColumns: TableColumn[];
+    responseActionRows: {
+        [key: TableColumn["value"]]: string;
+    }[];
+};
+
+export const ResponseActionTable: React.FC<ResponseActionTableProps> = React.memo(
+    ({ onChange, responseActionColumns, responseActionRows }) => {
+        const { goTo } = useRoutes();
+
+        const { icon: responseActionIcon, label: responseActionLabel } =
+            getResponseActionTableLabel(responseActionRows);
+
+        return (
+            <Section
+                title="Response Actions"
+                hasSeparator={true}
+                headerButton={
+                    <Button
+                        variant="outlined"
+                        color="secondary"
+                        startIcon={responseActionIcon}
+                        onClick={() => {
+                            goTo(RouteName.CREATE_FORM, {
+                                formType: "incident-response-action",
+                            });
+                        }}
+                    >
+                        {i18n.t(responseActionLabel)}
+                    </Button>
+                }
+                titleVariant="secondary"
+            >
+                <BasicTable
+                    onChange={onChange}
+                    columns={responseActionColumns}
+                    rows={responseActionRows}
+                />
+                <Box sx={{ m: 5 }} />
+            </Section>
+        );
+    }
+);
+
+function getResponseActionTableLabel(responseActionRows: TableRowType[]) {
+    const label =
+        responseActionRows.length === 0 ? "Add new Response Action" : "Edit Response Actions";
+    const icon = responseActionRows.length === 0 ? <AddCircleOutline /> : <EditOutlined />;
+
+    return { icon: icon, label: label };
+}
diff --git a/src/webapp/pages/incident-action-plan/useIncidentActionPlan.ts b/src/webapp/pages/incident-action-plan/useIncidentActionPlan.ts
new file mode 100644
index 00000000..0674fed2
--- /dev/null
+++ b/src/webapp/pages/incident-action-plan/useIncidentActionPlan.ts
@@ -0,0 +1,207 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Id } from "../../../domain/entities/Ref";
+import { Maybe } from "../../../utils/ts-utils";
+import { useAppContext } from "../../contexts/app-context";
+import { getDateAsLocaleDateTimeString } from "../../../data/repositories/utils/DateTimeHelper";
+import { TableColumn, TableRowType } from "../../components/table/BasicTable";
+import {
+    getIAPTypeByCode,
+    getPhoecLevelByCode,
+    getStatusTypeByCode,
+    getVerificationTypeByCode,
+} from "../../../data/repositories/consts/IncidentActionConstants";
+import {
+    IncidentActionOptions,
+    IncidentActionPlan,
+} from "../../../domain/entities/incident-action-plan/IncidentActionPlan";
+import { Option } from "../../components/utils/option";
+
+export type IncidentActionFormSummaryData = {
+    subTitle: string;
+    summary: Option[];
+};
+
+export type UIIncidentActionOptions = {
+    status: Option[];
+    verification: Option[];
+};
+
+export function useIncidentActionPlan(id: Id) {
+    const { compositionRoot } = useAppContext();
+
+    const [incidentAction, setIncidentAction] = useState<Option[] | undefined>();
+    const [actionPlanSummary, setActionPlanSummary] = useState<IncidentActionFormSummaryData>();
+    const [responseActionRows, setResponseActionRows] = useState<TableRowType[]>([]);
+    const [globalMessage, setGlobalMessage] = useState<string>();
+    const [incidentActionExists, setIncidentActionExists] = useState<boolean>(false);
+    const [incidentActionOptions, setIncidentActionOptions] = useState<UIIncidentActionOptions>();
+
+    const saveTableOption = useCallback(
+        (value: Maybe<string>, rowIndex: number, column: TableColumn["value"]) => {
+            const eventId = responseActionRows[rowIndex]?.id ?? "";
+            compositionRoot.incidentActionPlan.updateResponseAction
+                .execute({
+                    diseaseOutbreakId: id,
+                    eventId: eventId,
+                    responseAction: { value: value ?? "", type: column },
+                })
+                .run(
+                    () => console.debug(`${column} table option saved successfully`),
+                    err => setGlobalMessage(`Error saving table option: ${err}`)
+                );
+        },
+        [compositionRoot, id, responseActionRows]
+    );
+
+    const responseActionColumns: TableColumn[] = useMemo(() => {
+        return [
+            { value: "mainTask", label: "Main task", type: "text" },
+            { value: "subActivities", label: "Sub Activities", type: "text" },
+            { value: "subPillar", label: "Sub Pillar", type: "text" },
+            {
+                value: "searchAssignRO",
+                label: "Responsible officer",
+                type: "text",
+            },
+            {
+                value: "status",
+                label: "Status",
+                type: "selector",
+                options: incidentActionOptions?.status ?? [],
+                onChange: saveTableOption,
+            },
+            {
+                value: "verification",
+                label: "Verification",
+                type: "selector",
+                options: incidentActionOptions?.verification ?? [],
+                onChange: saveTableOption,
+            },
+            { value: "timeLine", label: "Timeline", type: "text" },
+            { value: "dueDate", label: "Due date", type: "text" },
+        ];
+    }, [incidentActionOptions, saveTableOption]);
+
+    useEffect(() => {
+        compositionRoot.incidentActionPlan.get.execute(id).run(
+            incidentActionPlan => {
+                const incidentActionExists = !!incidentActionPlan?.actionPlan?.id;
+                const incidentActionOptions = incidentActionPlan?.incidentActionOptions;
+
+                setIncidentActionExists(incidentActionExists);
+                setIncidentActionOptions(mapIncidentActionOptionsToTable(incidentActionOptions));
+                setIncidentAction(getIncidentActionFormSummary(incidentActionPlan));
+                setActionPlanSummary(mapIncidentActionPlanToFormSummary(incidentActionPlan));
+                setResponseActionRows(mapIncidentResponseActionToTableRows(incidentActionPlan));
+            },
+            err => {
+                console.debug(err);
+                setGlobalMessage(`Event tracker with id: ${id} does not exist`);
+            }
+        );
+    }, [compositionRoot, id]);
+
+    return {
+        incidentActionExists: incidentActionExists,
+        saveTableOption: saveTableOption,
+        responseActionColumns: responseActionColumns,
+        actionPlanSummary: actionPlanSummary,
+        formSummary: incidentAction,
+        responseActionRows: responseActionRows,
+        summaryError: globalMessage,
+    };
+}
+
+const getIncidentActionFormSummary = (incidentActionPlan: Maybe<IncidentActionPlan>): Option[] => {
+    if (!incidentActionPlan) return [];
+
+    const iapTypeCode = incidentActionPlan.actionPlan?.iapType ?? "";
+    const phoecLevelCode = incidentActionPlan.actionPlan?.phoecLevel ?? "";
+    const lastUpdated = getDateAsLocaleDateTimeString(new Date()); //TO DO : Fetch sync time from datastore once implemented
+
+    return [
+        {
+            label: "IAP last updated",
+            value: lastUpdated,
+        },
+        {
+            label: "IAP type",
+            value: getIAPTypeByCode(iapTypeCode) || "",
+        },
+        {
+            label: "PHOEC activation Level",
+            value: getPhoecLevelByCode(phoecLevelCode) || "",
+        },
+    ];
+};
+
+const mapIncidentActionPlanToFormSummary = (
+    incidentActionPlan: Maybe<IncidentActionPlan>
+): IncidentActionFormSummaryData => {
+    const actionPlan = incidentActionPlan?.actionPlan;
+    if (!actionPlan) return { subTitle: "Action Plan", summary: [] };
+
+    return {
+        subTitle: "Action Plan",
+        summary: [
+            {
+                label: "Response mode critical information requirements (CIRs)",
+                value: actionPlan.criticalInfoRequirements ?? "",
+            },
+            {
+                label: "Planning assumptions",
+                value: actionPlan.planningAssumptions ?? "",
+            },
+            {
+                label: "Response objectives (SMART)",
+                value: actionPlan.responseObjectives ?? "",
+            },
+            {
+                label: "Sections, functional area operational objectives, expected results",
+                value: actionPlan.expectedResults ?? "",
+            },
+            {
+                label: "Response activities narrative",
+                value: actionPlan.responseActivitiesNarrative ?? "",
+            },
+        ],
+    };
+};
+
+const mapIncidentResponseActionToTableRows = (
+    incidentActionPlan: Maybe<IncidentActionPlan>
+): TableRowType[] => {
+    if (incidentActionPlan) {
+        return incidentActionPlan.responseActions.map(responseAction => ({
+            id: responseAction.id,
+            mainTask: responseAction.mainTask,
+            subActivities: responseAction.subActivities,
+            subPillar: responseAction.subPillar,
+            searchAssignRO: responseAction.searchAssignRO?.username ?? "",
+            status: getStatusTypeByCode(responseAction.status) ?? "",
+            verification: getVerificationTypeByCode(responseAction.verification) ?? "",
+            timeLine: responseAction.timeLine,
+            dueDate: responseAction.dueDate.toISOString(),
+        }));
+    } else {
+        return [];
+    }
+};
+
+const mapIncidentActionOptionsToTable = (
+    incidentActionOptions: Maybe<IncidentActionOptions>
+): UIIncidentActionOptions => {
+    return {
+        status:
+            incidentActionOptions?.status.map(option => ({
+                value: getStatusTypeByCode(option.id) ?? "",
+                label: option.name,
+            })) ?? [],
+
+        verification:
+            incidentActionOptions?.verification.map(option => ({
+                value: getVerificationTypeByCode(option.id) ?? "",
+                label: option.name,
+            })) ?? [],
+    };
+};