diff --git a/backend/packages/Upgrade/src/api/services/ExperimentService.ts b/backend/packages/Upgrade/src/api/services/ExperimentService.ts
index 43ee1e1741..49cc6a0f95 100644
--- a/backend/packages/Upgrade/src/api/services/ExperimentService.ts
+++ b/backend/packages/Upgrade/src/api/services/ExperimentService.ts
@@ -298,31 +298,32 @@ export class ExperimentService {
           deleteAuditLogData,
           currentUser
         );
-
-        try {
-          await transactionalEntityManager
-            .getRepository(Segment)
-            .delete(experiment.experimentSegmentInclusion.segment.id);
-        } catch (err) {
-          const error = err as ErrorWithType;
-          error.details = 'Error in deleting Include Segment fron DB';
-          error.type = SERVER_ERROR.QUERY_FAILED;
-          logger.error(error);
-          throw error;
+        if (experiment.experimentSegmentInclusion) {
+          try {
+            await transactionalEntityManager
+              .getRepository(Segment)
+              .delete(experiment.experimentSegmentInclusion.segment.id);
+          } catch (err) {
+            const error = err as ErrorWithType;
+            error.details = 'Error in deleting Include Segment fron DB';
+            error.type = SERVER_ERROR.QUERY_FAILED;
+            logger.error(error);
+            throw error;
+          }
         }
-
-        try {
-          await transactionalEntityManager
-            .getRepository(Segment)
-            .delete(experiment.experimentSegmentExclusion.segment.id);
-        } catch (err) {
-          const error = err as ErrorWithType;
-          error.details = 'Error in deleting Exclude Segment fron DB';
-          error.type = SERVER_ERROR.QUERY_FAILED;
-          logger.error(error);
-          throw error;
+        if (experiment.experimentSegmentExclusion) {
+          try {
+            await transactionalEntityManager
+              .getRepository(Segment)
+              .delete(experiment.experimentSegmentExclusion.segment.id);
+          } catch (err) {
+            const error = err as ErrorWithType;
+            error.details = 'Error in deleting Exclude Segment fron DB';
+            error.type = SERVER_ERROR.QUERY_FAILED;
+            logger.error(error);
+            throw error;
+          }
         }
-
         return deletedExperiment;
       }
 
@@ -1131,79 +1132,100 @@ export class ExperimentService {
         logger.error(error);
         throw error;
       }
-
-      // creating Include Segment
+      let includeSegmentExists = true;
+      let segmentIncludeDoc: Segment;
+      let segmentIncludeDocToSave: Partial<ExperimentSegmentInclusion> = {};
       experimentDoc.experimentSegmentInclusion = experimentSegmentInclusion;
-      let segmentInclude;
-      if (experimentDoc.experimentSegmentInclusion.segment) {
-        const includeSegment = experimentDoc.experimentSegmentInclusion.segment;
-        segmentInclude = {
-          ...experimentSegmentInclusion,
-          type: includeSegment.type,
-          userIds: includeSegment.individualForSegment.map((x) => x.userId),
-          groups: includeSegment.groupForSegment.map((x) => {
-            return { type: x.type, groupId: x.groupId };
-          }),
-          subSegmentIds: includeSegment.subSegments.map((x) => x.id),
+      if (experimentDoc.experimentSegmentInclusion) {
+        // creating Include Segment
+        let segmentInclude;
+        if (experimentDoc.experimentSegmentInclusion.segment) {
+          const includeSegment = experimentDoc.experimentSegmentInclusion.segment;
+          segmentInclude = {
+            ...experimentSegmentInclusion,
+            type: includeSegment.type,
+            userIds: includeSegment.individualForSegment.map((x) => x.userId),
+            groups: includeSegment.groupForSegment.map((x) => {
+              return { type: x.type, groupId: x.groupId };
+            }),
+            subSegmentIds: includeSegment.subSegments.map((x) => x.id),
+          };
+        } else {
+          segmentInclude = experimentDoc.experimentSegmentInclusion;
+        }
+
+        const segmentIncludeData: SegmentInputValidator = {
+          ...segmentInclude,
+          id: uuid(),
+          name: experiment.id + ' Inclusion Segment',
+          description: experiment.id + ' Inclusion Segment',
+          context: experiment.context[0],
+          type: SEGMENT_TYPE.PRIVATE,
         };
+        try {
+          segmentIncludeDoc = await this.segmentService.upsertSegment(segmentIncludeData, logger);
+        } catch (err) {
+          const error = err as ErrorWithType;
+          error.details = 'Error in adding segment in DB';
+          error.type = SERVER_ERROR.QUERY_FAILED;
+          logger.error(error);
+          throw error;
+        }
+        // creating segmentInclude doc
+        const includeTempDoc = new ExperimentSegmentInclusion();
+        includeTempDoc.segment = segmentIncludeDoc;
+        includeTempDoc.experiment = experimentDoc;
+        segmentIncludeDocToSave = this.getSegmentDoc(includeTempDoc);
       } else {
-        segmentInclude = experimentDoc.experimentSegmentInclusion;
+        includeSegmentExists = false;
       }
 
-      const segmentIncludeData: SegmentInputValidator = {
-        ...segmentInclude,
-        id: uuid(),
-        name: experiment.id + ' Inclusion Segment',
-        description: experiment.id + ' Inclusion Segment',
-        context: experiment.context[0],
-        type: SEGMENT_TYPE.PRIVATE,
-      };
-      let segmentIncludeDoc: Segment;
-      try {
-        segmentIncludeDoc = await this.segmentService.upsertSegment(segmentIncludeData, logger);
-      } catch (err) {
-        const error = err as ErrorWithType;
-        error.details = 'Error in adding segment in DB';
-        error.type = SERVER_ERROR.QUERY_FAILED;
-        logger.error(error);
-        throw error;
-      }
-
-      // creating Exclude Segment
+      let excludeSegmentExists = true;
+      let segmentExcludeDoc: Segment;
+      let segmentExcludeDocToSave: Partial<ExperimentSegmentExclusion> = {};
       experimentDoc.experimentSegmentExclusion = experimentSegmentExclusion;
-      let segmentExclude;
-      if (experimentDoc.experimentSegmentExclusion.segment) {
-        const excludeSegment = experimentDoc.experimentSegmentExclusion.segment;
-        segmentExclude = {
-          ...experimentSegmentExclusion,
-          type: excludeSegment.type,
-          userIds: excludeSegment.individualForSegment.map((x) => x.userId),
-          groups: excludeSegment.groupForSegment.map((x) => {
-            return { type: x.type, groupId: x.groupId };
-          }),
-          subSegmentIds: excludeSegment.subSegments.map((x) => x.id),
+      if (experimentDoc.experimentSegmentExclusion) {
+        // creating Exclude Segment
+        let segmentExclude;
+        if (experimentDoc.experimentSegmentExclusion.segment) {
+          const excludeSegment = experimentDoc.experimentSegmentExclusion.segment;
+          segmentExclude = {
+            ...experimentSegmentExclusion,
+            type: excludeSegment.type,
+            userIds: excludeSegment.individualForSegment.map((x) => x.userId),
+            groups: excludeSegment.groupForSegment.map((x) => {
+              return { type: x.type, groupId: x.groupId };
+            }),
+            subSegmentIds: excludeSegment.subSegments.map((x) => x.id),
+          };
+        } else {
+          segmentExclude = experimentDoc.experimentSegmentExclusion;
+        }
+
+        const segmentExcludeData: SegmentInputValidator = {
+          ...segmentExclude,
+          id: uuid(),
+          name: experiment.id + ' Exclusion Segment',
+          description: experiment.id + ' Exclusion Segment',
+          context: experiment.context[0],
+          type: SEGMENT_TYPE.PRIVATE,
         };
+        try {
+          segmentExcludeDoc = await this.segmentService.upsertSegment(segmentExcludeData, logger);
+        } catch (err) {
+          const error = err as ErrorWithType;
+          error.details = 'Error in adding segment in DB';
+          error.type = SERVER_ERROR.QUERY_FAILED;
+          logger.error(error);
+          throw error;
+        }
+        // creating segmentExclude doc
+        const excludeTempDoc = new ExperimentSegmentExclusion();
+        excludeTempDoc.segment = segmentExcludeDoc;
+        excludeTempDoc.experiment = experimentDoc;
+        segmentExcludeDocToSave = this.getSegmentDoc(excludeTempDoc);
       } else {
-        segmentExclude = experimentDoc.experimentSegmentExclusion;
-      }
-
-      const segmentExcludeData: SegmentInputValidator = {
-        ...segmentExclude,
-        id: uuid(),
-        name: experiment.id + ' Exclusion Segment',
-        description: experiment.id + ' Exclusion Segment',
-        context: experiment.context[0],
-        type: SEGMENT_TYPE.PRIVATE,
-      };
-      let segmentExcludeDoc: Segment;
-      try {
-        segmentExcludeDoc = await this.segmentService.upsertSegment(segmentExcludeData, logger);
-      } catch (err) {
-        const error = err as ErrorWithType;
-        error.details = 'Error in adding segment in DB';
-        error.type = SERVER_ERROR.QUERY_FAILED;
-        logger.error(error);
-        throw error;
+        excludeSegmentExists = false;
       }
 
       // creating condition docs
@@ -1226,6 +1248,9 @@ export class ExperimentService {
           return decisionPoint;
         });
 
+      if (!conditionPayloads) {
+        experiment = { ...experiment, conditionPayloads: [] };
+      }
       // update conditionPayloads condition uuids:
       if (conditionPayloads) {
         conditionPayloads.map((conditionPayload) => {
@@ -1237,7 +1262,6 @@ export class ExperimentService {
           }
         });
       }
-
       const conditionPayloadDocToSave: Array<Partial<ConditionPayload>> =
         (conditionPayloads &&
           conditionPayloads.length > 0 &&
@@ -1253,22 +1277,12 @@ export class ExperimentService {
           })) ||
         [];
 
-      // creating segmentInclude doc
-      const includeTempDoc = new ExperimentSegmentInclusion();
-      includeTempDoc.segment = segmentIncludeDoc;
-      includeTempDoc.experiment = experimentDoc;
-      const segmentIncludeDocToSave = this.getSegmentDoc(includeTempDoc);
-
-      // creating segmentExclude doc
-      const excludeTempDoc = new ExperimentSegmentExclusion();
-      excludeTempDoc.segment = segmentExcludeDoc;
-      excludeTempDoc.experiment = experimentDoc;
-      const segmentExcludeDocToSave = this.getSegmentDoc(excludeTempDoc);
       // creating queries docs
       const promiseArray = [];
       let queryDocsToSave =
-        (queries[0] &&
+        (queries &&
           queries.length > 0 &&
+          queries[0] &&
           queries.map((query: any) => {
             promiseArray.push(this.metricRepository.findOne(query.metric.key));
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -1307,17 +1321,26 @@ export class ExperimentService {
         ] = await Promise.all([
           this.experimentConditionRepository.insertConditions(conditionDocsToSave, transactionalEntityManager),
           this.decisionPointRepository.insertDecisionPoint(decisionPointDocsToSave, transactionalEntityManager),
-          this.experimentSegmentInclusionRepository.insertData(
-            segmentIncludeDocToSave,
-            logger,
-            transactionalEntityManager
-          ),
-          this.experimentSegmentExclusionRepository.insertData(
-            segmentExcludeDocToSave,
-            logger,
-            transactionalEntityManager
-          ),
-          this.conditionPayloadRepository.insertConditionPayload(conditionPayloadDocToSave, transactionalEntityManager),
+          includeSegmentExists
+            ? this.experimentSegmentInclusionRepository.insertData(
+                segmentIncludeDocToSave,
+                logger,
+                transactionalEntityManager
+              )
+            : (Promise.resolve([]) as any),
+          excludeSegmentExists
+            ? this.experimentSegmentExclusionRepository.insertData(
+                segmentExcludeDocToSave,
+                logger,
+                transactionalEntityManager
+              )
+            : (Promise.resolve([]) as any),
+          conditionPayloadDocToSave.length > 0
+            ? this.conditionPayloadRepository.insertConditionPayload(
+                conditionPayloadDocToSave,
+                transactionalEntityManager
+              )
+            : (Promise.resolve([]) as any),
           queryDocsToSave.length > 0
             ? this.queryRepository.insertQueries(queryDocsToSave, transactionalEntityManager)
             : (Promise.resolve([]) as any),
@@ -1361,17 +1384,29 @@ export class ExperimentService {
         factorDocToReturn = this.formatingFactorAndLevels(factorDoc, levelDoc);
         conditionDocToReturn = this.formatingElements(conditionDocToReturn, levelCombinationElementDoc, levelDoc);
       }
-
-      const newExperiment = {
-        ...experimentDoc,
-        conditions: conditionDocToReturn as any,
-        partitions: decisionPointDocToReturn as any,
-        factors: factorDocToReturn as any,
-        experimentSegmentInclusion: { ...experimentSegmentInclusionDoc, segment: segmentIncludeDoc } as any,
-        experimentSegmentExclusion: { ...experimentSegmentExclusionDoc, segment: segmentExcludeDoc } as any,
-        conditionPayloads: conditionPayloadDocToReturn as any,
-        queries: (queryDocToReturn as any) || [],
-      };
+      let newExperimentObject;
+      if (experimentDoc.experimentSegmentInclusion && experimentDoc.experimentSegmentExclusion) {
+        newExperimentObject = {
+          ...experimentDoc,
+          conditions: conditionDocToReturn as any,
+          partitions: decisionPointDocToReturn as any,
+          factors: factorDocToReturn as any,
+          experimentSegmentInclusion: { ...experimentSegmentInclusionDoc, segment: segmentIncludeDoc } as any,
+          experimentSegmentExclusion: { ...experimentSegmentExclusionDoc, segment: segmentExcludeDoc } as any,
+          conditionPayloads: conditionPayloadDocToReturn as any,
+          queries: (queryDocToReturn as any) || [],
+        };
+      } else {
+        newExperimentObject = {
+          ...experimentDoc,
+          conditions: conditionDocToReturn as any,
+          partitions: decisionPointDocToReturn as any,
+          factors: factorDocToReturn as any,
+          conditionPayloads: conditionPayloadDocToReturn as any,
+          queries: (queryDocToReturn as any) || [],
+        };
+      }
+      const newExperiment = newExperimentObject;
       return newExperiment;
     });
     // create schedules to start experiment and end experiment
diff --git a/frontend/projects/upgrade/src/app/features/dashboard/home/components/experiment-participants/experiment-participants.component.ts b/frontend/projects/upgrade/src/app/features/dashboard/home/components/experiment-participants/experiment-participants.component.ts
index 887472d7a9..dab45ab97a 100644
--- a/frontend/projects/upgrade/src/app/features/dashboard/home/components/experiment-participants/experiment-participants.component.ts
+++ b/frontend/projects/upgrade/src/app/features/dashboard/home/components/experiment-participants/experiment-participants.component.ts
@@ -124,8 +124,11 @@ export class ExperimentParticipantsComponent implements OnInit {
     });
 
     this.participantsForm.get('inclusionCriteria').setValue(INCLUSION_CRITERIA.INCLUDE_SPECIFIC);
-
-    if (this.experimentInfo) {
+    if (
+      this.experimentInfo &&
+      this.experimentInfo.experimentSegmentInclusion &&
+      this.experimentInfo.experimentSegmentExclusion
+    ) {
       if (this.experimentInfo.filterMode === FILTER_MODE.EXCLUDE_ALL) {
         this.participantsForm.get('inclusionCriteria').setValue(INCLUSION_CRITERIA.INCLUDE_SPECIFIC);
         this.experimentInfo.experimentSegmentInclusion.segment.individualForSegment.forEach((id) => {
@@ -167,6 +170,7 @@ export class ExperimentParticipantsComponent implements OnInit {
           this.members2.push(this.addMembers2(MemberTypes.SEGMENT, id.name));
         });
       }
+    } else {
       this.members1.removeAt(0);
       this.members2.removeAt(0);
     }
diff --git a/frontend/projects/upgrade/src/app/features/dashboard/home/components/modal/import-experiment/import-experiment.component.html b/frontend/projects/upgrade/src/app/features/dashboard/home/components/modal/import-experiment/import-experiment.component.html
index 2632f05b83..c20dc9e774 100644
--- a/frontend/projects/upgrade/src/app/features/dashboard/home/components/modal/import-experiment/import-experiment.component.html
+++ b/frontend/projects/upgrade/src/app/features/dashboard/home/components/modal/import-experiment/import-experiment.component.html
@@ -13,13 +13,13 @@
         <ng-container matColumnDef="File Name">
           <mat-header-cell class="ft-12-700" *matHeaderCellDef> File Name </mat-header-cell>
           <mat-cell class="ft-12-600" *matCellDef="let element">
-            {{ element.fileName }}
+            {{ element.filename }}
           </mat-cell>
         </ng-container>
 
         <!-- Error -->
         <ng-container matColumnDef="Error">
-          <mat-header-cell class="ft-12-700" *matHeaderCellDef> Error </mat-header-cell>
+          <mat-header-cell class="ft-12-700" *matHeaderCellDef> Error/Warning </mat-header-cell>
           <mat-cell class="ft-12-600" *matCellDef="let element">
             {{ element.error }}
           </mat-cell>
@@ -42,8 +42,11 @@
     <button
       mat-raised-button
       class="shared-modal--modal-btn default-button"
-      [ngClass]="{ 'default-button--disabled': uploadedFileCount === 1 && (!experimentInfo || !isExperimentJSONValid) }"
-      [disabled]="uploadedFileCount === 1 && (!experimentInfo || !isExperimentJSONValid)"
+      [ngClass]="{
+        'default-button--disabled':
+          uploadedFileCount === 0 || (uploadedFileCount === 1 && (!experimentInfo || !isExperimentJSONValid))
+      }"
+      [disabled]="uploadedFileCount === 0 || (uploadedFileCount === 1 && (!experimentInfo || !isExperimentJSONValid))"
       (click)="importExperiment()"
     >
       {{ 'global.import.text' | translate }}
diff --git a/frontend/projects/upgrade/src/app/features/dashboard/home/components/modal/import-experiment/import-experiment.component.scss b/frontend/projects/upgrade/src/app/features/dashboard/home/components/modal/import-experiment/import-experiment.component.scss
index 66ef539699..e6344ed902 100644
--- a/frontend/projects/upgrade/src/app/features/dashboard/home/components/modal/import-experiment/import-experiment.component.scss
+++ b/frontend/projects/upgrade/src/app/features/dashboard/home/components/modal/import-experiment/import-experiment.component.scss
@@ -8,6 +8,8 @@
   .import-experiment-body {
     margin: 20px 0;
     padding: 0 40px;
+    height: 265px;
+    overflow-y: auto;
 
     .file-input {
       &:hover {
diff --git a/frontend/projects/upgrade/src/app/features/dashboard/home/components/modal/import-experiment/import-experiment.component.ts b/frontend/projects/upgrade/src/app/features/dashboard/home/components/modal/import-experiment/import-experiment.component.ts
index 0b9736fc09..bdae910fd4 100644
--- a/frontend/projects/upgrade/src/app/features/dashboard/home/components/modal/import-experiment/import-experiment.component.ts
+++ b/frontend/projects/upgrade/src/app/features/dashboard/home/components/modal/import-experiment/import-experiment.component.ts
@@ -17,7 +17,7 @@ import { filter } from 'rxjs/operators';
 import { v4 as uuidv4 } from 'uuid';
 import { MatLegacySnackBar as MatSnackBar } from '@angular/material/legacy-snack-bar';
 import { MatLegacyTableDataSource as MatTableDataSource } from '@angular/material/legacy-table';
-import { EXPERIMENT_TYPE } from 'upgrade_types';
+import { EXPERIMENT_TYPE, FILTER_MODE } from 'upgrade_types';
 
 interface ImportExperimentJSON {
   schema:
@@ -45,16 +45,114 @@ interface ImportExperimentJSON {
 })
 export class ImportExperimentComponent implements OnInit {
   experimentInfo: Experiment;
-  isExperimentJSONValid = true;
-  experimentJSONVersionStatus = 0;
+  isExperimentJSONValid: boolean = true;
+  experimentJSONVersionStatus: number = 0;
   missingAllProperties: string;
-  allPartitions = [];
+  allPartitions: ExperimentDecisionPoint[] = [];
   allPartitionsSub: Subscription;
   allExperiments: Experiment[] = [];
   importFileErrorsDataSource = new MatTableDataSource<{ filename: string; error: string }>();
   importFileErrors: { filename: string; error: string }[] = [];
   displayedColumns: string[] = ['File Name', 'Error'];
-  uploadedFileCount: any;
+  uploadedFileCount: number = 0;
+
+  missingConditionProperties: string = '';
+  missingPartitionProperties: string = '';
+  missingFactorProperties: string = '';
+  missingLevelProperties: string = '';
+  missingLevelCombinationElementProperties: string = '';
+  missingPropertiesFlag: boolean = false;
+  isFactorialExperiment: boolean;
+
+  // TODO remove this any after typescript version updation
+  experimentSchema: any = {
+    id: 'string',
+    name: 'string',
+    description: 'string',
+    createdAt: 'string',
+    updatedAt: 'string',
+    versionNumber: 'number',
+    state: 'enum',
+    context: 'array',
+    startOn: 'string',
+    consistencyRule: 'enum',
+    assignmentUnit: 'enum',
+    postExperimentRule: 'enum',
+    enrollmentCompleteCondition: 'enum',
+    endOn: 'string',
+    revertTo: 'string',
+    tags: 'array',
+    logging: 'boolean',
+    group: 'string',
+    conditions: 'interface',
+    partitions: 'interface',
+    factors: 'interface',
+    queries: 'array',
+    stateTimeLogs: 'interface',
+    filterMode: 'string',
+    experimentSegmentInclusion: 'interface',
+    experimentSegmentExclusion: 'interface',
+    backendVersion: 'string',
+  };
+
+  conditionSchema: Record<keyof ExperimentCondition, string> = {
+    id: 'string',
+    name: 'string',
+    description: 'string',
+    conditionCode: 'string',
+    assignmentWeight: 'number',
+    twoCharacterId: 'string',
+    order: 'number',
+    createdAt: 'string',
+    updatedAt: 'string',
+    versionNumber: 'number',
+    levelCombinationElements: 'interface',
+  };
+
+  conditionSchemaForSimpleExp: Record<keyof ExperimentConditionForSimpleExp, string> = {
+    id: 'string',
+    name: 'string',
+    description: 'string',
+    conditionCode: 'string',
+    assignmentWeight: 'number',
+    twoCharacterId: 'string',
+    order: 'number',
+    createdAt: 'string',
+    updatedAt: 'string',
+    versionNumber: 'number',
+  };
+
+  levelCombinationElementSchema: Record<keyof LevelCombinationElement, string> = {
+    id: 'string',
+    level: 'interface',
+  };
+
+  partitionSchema: Record<keyof ExperimentDecisionPoint, string> = {
+    id: 'string',
+    site: 'string',
+    target: 'string',
+    description: 'string',
+    twoCharacterId: 'string',
+    order: 'number',
+    createdAt: 'string',
+    updatedAt: 'string',
+    versionNumber: 'number',
+    excludeIfReached: 'boolean',
+  };
+
+  factorSchema: Record<keyof ExperimentFactor, string> = {
+    name: 'string',
+    description: 'string',
+    order: 'number',
+    levels: 'interface',
+  };
+
+  levelSchema: Record<keyof ExperimentLevel, string> = {
+    id: 'string',
+    name: 'string',
+    payload: 'string',
+    order: 'number',
+  };
 
   constructor(
     private experimentService: ExperimentService,
@@ -83,6 +181,13 @@ export class ImportExperimentComponent implements OnInit {
     this.dialogRef.close();
   }
 
+  /* Check if string is valid UUID */
+  checkIfValidUUID(str: string) {
+    // Regular expression to check if string is a valid UUID
+    const regexExp = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/gi;
+    return regexExp.test(str);
+  }
+
   importExperiment() {
     this.allExperiments.forEach((exp) => {
       exp.id = uuidv4();
@@ -90,6 +195,11 @@ export class ImportExperimentComponent implements OnInit {
         condition.id = condition.id || uuidv4();
       });
     });
+    this.allExperiments.forEach((exp) => {
+      exp.partitions.map((decisionPoint) => {
+        decisionPoint.id = this.checkIfValidUUID(decisionPoint.id) ? decisionPoint.id : uuidv4();
+      });
+    });
     this.experimentService.importExperiment(this.allExperiments);
     this.onCancelClick();
     this.openSnackBar();
@@ -140,186 +250,156 @@ export class ImportExperimentComponent implements OnInit {
     }
   }
 
-  validateExperimentJSON(experiment: Experiment) {
-    // TODO remove this any after typescript version updation
-    const experimentSchema: any = {
-      id: 'string',
-      name: 'string',
-      description: 'string',
-      createdAt: 'string',
-      updatedAt: 'string',
-      versionNumber: 'number',
-      state: 'enum',
-      context: 'array',
-      startOn: 'string',
-      consistencyRule: 'enum',
-      assignmentUnit: 'enum',
-      postExperimentRule: 'enum',
-      enrollmentCompleteCondition: 'enum',
-      endOn: 'string',
-      revertTo: 'string',
-      tags: 'array',
-      logging: 'boolean',
-      group: 'string',
-      conditions: 'interface',
-      partitions: 'interface',
-      factors: 'interface',
-      queries: 'array',
-      stateTimeLogs: 'interface',
-      filterMode: 'string',
-      experimentSegmentInclusion: 'interface',
-      experimentSegmentExclusion: 'interface',
-      backendVersion: 'string',
-    };
-
-    const conditionSchema: Record<keyof ExperimentCondition, string> = {
-      id: 'string',
-      name: 'string',
-      description: 'string',
-      conditionCode: 'string',
-      assignmentWeight: 'number',
-      twoCharacterId: 'string',
-      order: 'number',
-      createdAt: 'string',
-      updatedAt: 'string',
-      versionNumber: 'number',
-      levelCombinationElements: 'interface',
-    };
-
-    const conditionSchemaForSimpleExp: Record<keyof ExperimentConditionForSimpleExp, string> = {
-      id: 'string',
-      name: 'string',
-      description: 'string',
-      conditionCode: 'string',
-      assignmentWeight: 'number',
-      twoCharacterId: 'string',
-      order: 'number',
-      createdAt: 'string',
-      updatedAt: 'string',
-      versionNumber: 'number',
-    };
-
-    const partitionSchema: Record<keyof ExperimentDecisionPoint, string> = {
-      id: 'string',
-      site: 'string',
-      target: 'string',
-      description: 'string',
-      twoCharacterId: 'string',
-      order: 'number',
-      createdAt: 'string',
-      updatedAt: 'string',
-      versionNumber: 'number',
-      excludeIfReached: 'boolean',
-    };
-
-    const factorSchema: Record<keyof ExperimentFactor, string> = {
-      name: 'string',
-      description: 'string',
-      order: 'number',
-      levels: 'interface',
-    };
-
-    const levelSchema: Record<keyof ExperimentLevel, string> = {
-      id: 'string',
-      name: 'string',
-      payload: 'string',
-      order: 'number',
-    };
-
-    const levelCombinationElementSchema: Record<keyof LevelCombinationElement, string> = {
-      id: 'string',
-      level: 'interface',
-    };
-
-    const missingProperties = this.checkForMissingProperties({ schema: experimentSchema, data: experiment });
-    const isFactorialExperiment = experiment.type === EXPERIMENT_TYPE.FACTORIAL;
-    let missingPropertiesFlag = true;
+  async validateExperimentJSON(experiment: Experiment) {
+    let missingProperties = this.checkForMissingProperties({ schema: this.experimentSchema, data: experiment });
+    const missingPropertiesList = missingProperties !== '' ? missingProperties.split(', ') : [];
+
+    if (missingPropertiesList.includes('backendVersion')) {
+      const currentBackendVersion = await this.versionService.getVersion();
+      experiment = { ...experiment, backendVersion: currentBackendVersion.toString() };
+      const index = missingPropertiesList.indexOf('backendVersion');
+      if (index > -1) {
+        missingPropertiesList.splice(index, 1);
+      }
+    }
+
+    if (missingPropertiesList.includes('filterMode')) {
+      experiment = { ...experiment, filterMode: FILTER_MODE.INCLUDE_ALL };
+      const index = missingPropertiesList.indexOf('filterMode');
+      if (index > -1) {
+        missingPropertiesList.splice(index, 1);
+      }
+    }
+
+    missingProperties = missingPropertiesList.join(', ');
+
+    this.isFactorialExperiment = experiment.type === EXPERIMENT_TYPE.FACTORIAL;
+
     this.missingAllProperties =
       this.translate.instant('home.import-experiment.missing-properties.message.text') + missingProperties;
-    let missingConditionProperties;
-    let missingPartitionProperties;
-    let missingFactorProperties;
-    let missingLevelProperties;
-    let missingLevelCombinationElementProperties;
-
-    missingPropertiesFlag = missingPropertiesFlag && missingProperties.length === 0;
-    experiment.conditions.map((condition) => {
-      missingConditionProperties = this.checkForMissingProperties({
-        schema: isFactorialExperiment ? conditionSchema : conditionSchemaForSimpleExp,
-        data: condition,
-      });
 
-      if (isFactorialExperiment) {
-        condition.levelCombinationElements.map((element) => {
-          missingLevelCombinationElementProperties = this.checkForMissingProperties({
-            schema: levelCombinationElementSchema,
-            data: element,
-          });
-        });
-        if (missingLevelCombinationElementProperties.length > 0) {
-          this.missingAllProperties =
-            this.missingAllProperties +
-            ', ' +
-            this.translate.instant('global.level.text') +
-            ': ' +
-            missingLevelCombinationElementProperties;
-        }
-        missingPropertiesFlag = missingPropertiesFlag && missingLevelCombinationElementProperties.length === 0;
-      }
-    });
-    if (missingConditionProperties.length > 0) {
+    this.missingPropertiesFlag = this.updateMissingPropertiesFlag(missingProperties);
+    
+
+    this.checkMissingConditionProperties(experiment.conditions);
+    
+    if (this.missingConditionProperties.length > 0) {
       this.missingAllProperties =
         this.missingAllProperties +
         ', ' +
         this.translate.instant('global.condition.text') +
         ': ' +
-        missingConditionProperties;
+        this.missingConditionProperties;
     }
-    missingPropertiesFlag = missingPropertiesFlag && missingConditionProperties.length === 0;
-    experiment.partitions.map((partition) => {
-      missingPartitionProperties = this.checkForMissingProperties({
-        schema: partitionSchema,
-        data: partition,
-      });
 
-      //
-    });
-    if (missingPartitionProperties.length > 0) {
+    this.missingPropertiesFlag = this.updateMissingPropertiesFlag(this.missingConditionProperties);
+
+    this.checkMissingPartitionProperties(experiment.partitions);
+
+    const missingPartitionPropertiesList = this.missingPartitionProperties.split(', ');
+
+    if (missingPartitionPropertiesList.length > 0) {
+      if (missingPartitionPropertiesList.includes('excludeIfReached')) {
+        experiment.partitions = this.addMissingExcludeIfReachedProperty(experiment.partitions);
+
+        const index = missingPartitionPropertiesList.indexOf('excludeIfReached');
+        if (index > -1) {
+          missingPartitionPropertiesList.splice(index, 1);
+        }
+      }
+    }
+    this.missingPartitionProperties = missingPartitionPropertiesList.join(', ');
+
+    if (this.missingPartitionProperties.length > 0) {
       this.missingAllProperties =
         this.missingAllProperties +
         ', ' +
         this.translate.instant('global.decision-points.text') +
         ': ' +
-        missingPartitionProperties;
+        this.missingPartitionProperties;
     }
-    if (isFactorialExperiment) {
-      experiment.factors.map((factor) => {
-        missingFactorProperties = this.checkForMissingProperties({ schema: factorSchema, data: factor });
+
+    if (this.isFactorialExperiment) {
+      this.checkMissingFactorAndLevelProperties(experiment.factors);
+      
+      if (this.missingFactorProperties.length > 0) {
+        this.missingAllProperties =
+          this.missingAllProperties +
+          ', ' +
+          this.translate.instant('global.factor.text') +
+          ': ' +
+          this.missingFactorProperties;
+      }
+      this.missingPropertiesFlag = this.updateMissingPropertiesFlag(this.missingFactorProperties);
+    }
+
+    this.missingPropertiesFlag = this.updateMissingPropertiesFlag(this.missingPartitionProperties);
+    
+    return !this.missingPropertiesFlag;
+  }
+  updateMissingPropertiesFlag(missingPropertiesList: string): boolean {
+    return this.missingPropertiesFlag && missingPropertiesList.length !== 0;
+  }
+
+  addMissingExcludeIfReachedProperty(partitions: ExperimentDecisionPoint[]): ExperimentDecisionPoint[] {
+    return partitions.map((decisionPoint) => {
+      return { ...decisionPoint, excludeIfReached: false };
+    });
+  }
+
+  checkMissingFactorAndLevelProperties(factors: ExperimentFactor[]) {
+    factors.map((factor) => {
+        this.missingFactorProperties = this.checkForMissingProperties({ schema: this.factorSchema, data: factor });
         factor.levels.map((level) => {
-          missingLevelProperties = this.checkForMissingProperties({ schema: levelSchema, data: level });
+          this.missingLevelProperties = this.checkForMissingProperties({ schema: this.levelSchema, data: level });
         });
-        if (missingLevelProperties.length > 0) {
+
+        if (this.missingLevelProperties.length > 0) {
           this.missingAllProperties =
             this.missingAllProperties +
             ', ' +
             this.translate.instant('global.levelCombinationElement.text') +
             ': ' +
-            missingLevelProperties;
+            this.missingLevelProperties;
         }
-        missingPropertiesFlag = missingPropertiesFlag && missingLevelProperties.length === 0;
+        this.missingPropertiesFlag = this.missingPropertiesFlag && this.missingLevelProperties.length !== 0;
       });
-      if (missingFactorProperties.length > 0) {
-        this.missingAllProperties =
-          this.missingAllProperties +
-          ', ' +
-          this.translate.instant('global.factor.text') +
-          ': ' +
-          missingFactorProperties;
+  }
+
+  checkMissingPartitionProperties(partitions: ExperimentDecisionPoint[]) {
+    partitions.map((partition) => {
+      this.missingPartitionProperties = this.checkForMissingProperties({
+        schema: this.partitionSchema,
+        data: partition,
+      });
+    });
+  }
+
+  checkMissingConditionProperties(conditions: ExperimentCondition[]) {
+    conditions.map((condition) => {
+      this.missingConditionProperties = this.checkForMissingProperties({
+        schema: this.isFactorialExperiment ? this.conditionSchema : this.conditionSchemaForSimpleExp,
+        data: condition,
+      });
+
+      if (this.isFactorialExperiment) {
+        condition.levelCombinationElements.map((element) => {
+          this.missingLevelCombinationElementProperties = this.checkForMissingProperties({
+            schema: this.levelCombinationElementSchema,
+            data: element,
+          });
+        });
+        if (this.missingLevelCombinationElementProperties.length > 0) {
+          this.missingAllProperties =
+            this.missingAllProperties +
+            ', ' +
+            this.translate.instant('global.level.text') +
+            ': ' +
+            this.missingLevelCombinationElementProperties;
+        }
+        this.missingPropertiesFlag = this.missingPropertiesFlag && this.missingLevelCombinationElementProperties.length !== 0;
       }
-      missingPropertiesFlag = missingPropertiesFlag && missingFactorProperties.length === 0;
-    }
-    missingPropertiesFlag = missingPropertiesFlag && missingPartitionProperties.length === 0;
-    return missingPropertiesFlag;
+    });
   }
 
   private checkForMissingProperties(experimentJson: ImportExperimentJSON) {
@@ -342,6 +422,102 @@ export class ImportExperimentComponent implements OnInit {
     return missingProperty.join(', ');
   }
 
+  deduceConditionPayload(result) {
+    if (result.conditionAliases) {
+      result.conditionPayloads = result.conditionAliases;
+      result.conditionAliases.forEach((payload, payloadIndex) => {
+        result.conditionPayloads[payloadIndex].payload = {};
+        result.conditionPayloads[payloadIndex].payload.type = 'string';
+        result.conditionPayloads[payloadIndex].payload.value = payload.aliasName;
+      });
+      delete result.conditionAliases;
+    }
+
+    return result;
+  }
+
+  deducePartition(result) {
+    result.partitions.forEach((decisionPoint, decisionPointIndex) => {
+      if (decisionPoint.expPoint) {
+        result.partitions[decisionPointIndex].site = decisionPoint.expPoint;
+        delete result.partitions[decisionPointIndex].expPoint;
+      }
+
+      if (decisionPoint.expId) {
+        result.partitions[decisionPointIndex].target = decisionPoint.expId;
+        delete result.partitions[decisionPointIndex].expId;
+      }
+
+      if (decisionPoint.factors) {
+        result.partitions[decisionPointIndex].factors.forEach((factor) => {
+          result.factors.push(factor);
+        });
+        delete result.partitions[decisionPointIndex].factors;
+      }
+    });
+
+    return result;
+  }
+
+  deduceFactors(result) {
+    result.factors.forEach((factor, factorIndex) => {
+      factor.levels.forEach((level, levelIndex) => {
+        if (level.alias) {
+          result.factors[factorIndex].levels[levelIndex].payload = {};
+          result.factors[factorIndex].levels[levelIndex].payload.type = 'string';
+          result.factors[factorIndex].levels[levelIndex].payload.value = level.alias;
+          delete result.factors[factorIndex].levels[levelIndex].alias;
+        }
+      });
+    });
+    return result;
+  }
+
+  updateExperimentJSON(result) {
+    // adding missing fields:
+    if (!result.factors) {
+      result.factors = [];
+    }
+    // replacing old fields with new field names:
+    result = this.deduceConditionPayload(result);
+    result = this.deducePartition(result);
+    result = this.deduceFactors(result);
+    
+    return result;
+  }
+
+  async validateExperiment(experimentInfo, fileName, experimentJSONVersionStatus) {
+    if (experimentInfo.backendVersion) {
+      experimentJSONVersionStatus = await this.validateExperimentJSONVersion(experimentInfo);
+    }
+
+    let isExperimentJSONValid = await this.validateExperimentJSON(experimentInfo);
+
+    if (experimentJSONVersionStatus === 0 && isExperimentJSONValid) {
+      this.allExperiments.push(experimentInfo);
+    } else if (!isExperimentJSONValid) {
+      this.importFileErrors.push({
+        filename: fileName,
+        error:
+          this.translate.instant('home.import-experiment.error.message.text') + ' ' + this.missingAllProperties,
+      });
+    } else {
+      if (experimentJSONVersionStatus === 1) {
+        this.importFileErrors.push({
+          filename: fileName,
+          error: this.translate.instant('home.import-experiment.old-version-error.message.text'),
+        });
+      } else {
+        this.importFileErrors.push({
+          filename: fileName,
+          error: this.translate.instant('home.import-experiment.new-version-error.message.text'),
+        });
+      }
+      this.allExperiments.push(experimentInfo);
+    }
+    return this.importFileErrors;
+  }
+
   async uploadFile(event) {
     let index = 0;
     let fileName = '';
@@ -359,34 +535,10 @@ export class ImportExperimentComponent implements OnInit {
     reader.addEventListener(
       'load',
       async function () {
-        const result = JSON.parse(reader.result as any);
+        let result = JSON.parse(reader.result as any);
+        result = this.updateExperimentJSON(result);
         this.experimentInfo = result;
-        this.experimentJSONVersionStatus = await this.validateExperimentJSONVersion(this.experimentInfo);
-        this.isExperimentJSONValid = this.validateExperimentJSON(this.experimentInfo);
-        if (this.experimentJSONVersionStatus === 0 && this.isExperimentJSONValid) {
-          this.allExperiments.push(this.experimentInfo);
-        } else if (!this.isExperimentJSONValid) {
-          this.importFileErrors.push({
-            fileName: fileName,
-            error:
-              this.translate.instant('home.import-experiment.error.message.text') + ' ' + this.missingAllProperties,
-          });
-        } else {
-          if (this.experimentJSONVersionStatus === 1) {
-            this.importFileErrors.push({
-              fileName: fileName,
-              error: this.translate.instant('home.import-experiment.old-version-error.message.text'),
-            });
-          } else {
-            this.importFileErrors.push({
-              fileName: fileName,
-              error: this.translate.instant('home.import-experiment.new-version-error.message.text'),
-            });
-          }
-          this.allExperiments.push(this.experimentInfo);
-        }
-
-        this.importFileErrorsDataSource.data = this.importFileErrors;
+        this.importFileErrorsDataSource.data = await this.validateExperiment(this.experimentInfo, fileName, this.experimentJSONVersionStatus);
         readFile(++index);
       }.bind(this)
     );
diff --git a/frontend/projects/upgrade/src/app/features/dashboard/home/pages/view-experiment/view-experiment.component.ts b/frontend/projects/upgrade/src/app/features/dashboard/home/pages/view-experiment/view-experiment.component.ts
index b010f2b28c..d9d4842af2 100644
--- a/frontend/projects/upgrade/src/app/features/dashboard/home/pages/view-experiment/view-experiment.component.ts
+++ b/frontend/projects/upgrade/src/app/features/dashboard/home/pages/view-experiment/view-experiment.component.ts
@@ -213,7 +213,7 @@ export class ViewExperimentComponent implements OnInit, OnDestroy {
   }
 
   loadParticipants() {
-    if (this.experiment) {
+    if (this.experiment && this.experiment.experimentSegmentInclusion && this.experiment.experimentSegmentExclusion) {
       this.includeParticipants = [];
       this.excludeParticipants = [];
       this.experiment.experimentSegmentInclusion.segment.individualForSegment.forEach((id) => {
diff --git a/frontend/projects/upgrade/src/assets/i18n/en.json b/frontend/projects/upgrade/src/assets/i18n/en.json
index 221ec0a8de..36219a603c 100644
--- a/frontend/projects/upgrade/src/assets/i18n/en.json
+++ b/frontend/projects/upgrade/src/assets/i18n/en.json
@@ -255,8 +255,9 @@
   "home.view-experiment.mattab.metrics.text": "Metrics",
   "home.import-experiment.message.text": "Select the JSON to import experiment:",
   "home.import-experiment.error.message.text": "Invalid Experiment JSON data",
-  "home.import-experiment.old-version-error.message.text": "Imported experiment version is older than the current Upgrade Version. Some parts may not function as intended. (Still you can import it)",
-  "home.import-experiment.new-version-error.message.text": "Imported experiment version is newer than the current Upgrade Version. Some parts may not function as intended. (Still you can import it)",
+  "home.import-experiment.old-version-error.message.text": "Warning: this experiment file is incompatible(older) with the current version of UpGrade. Some features may not import or function as intended. Continue with import?",
+  "home.import-experiment.new-version-error.message.text": "Warning: this experiment file is incompatible(newer) with the current version of UpGrade. Some features may not import or function as intended. Continue with import?",
+  
   "home.import-experiment.missing-properties.message.text": "The document is missing the following properties: ",
   "home.import-experiment.multiple-files-import.warning.message.text": "Non-error experiments will be imported",
   "home.change-experiment-status.title.text": "Change Experiment Status",