diff --git a/src/app/instances/pdu-instances/add-pdu-instances/AddPDUInstancesComponent.html b/src/app/instances/pdu-instances/add-pdu-instances/AddPDUInstancesComponent.html
index f785426..54e36fa 100644
--- a/src/app/instances/pdu-instances/add-pdu-instances/AddPDUInstancesComponent.html
+++ b/src/app/instances/pdu-instances/add-pdu-instances/AddPDUInstancesComponent.html
@@ -70,7 +70,7 @@
                         <div class="row mr-top-5">
                             <label class="col-sm-2 col-form-label" for="mgmt{{i}}">{{'MGMT' | translate}}*</label>
                             <div class="col-sm-4">
-                                <ng-select placeholder="{{'SELECT' | translate}} {{'MGMT' | translate}}" [items]="mgmtState" bindLabel="name" bindValue="value" formControlName="mgmt" id="mgmt{{i}}" [(ngModel)]="selectedMgmt" [ngClass]="{ 'is-invalid': submitted && params.controls.mgmt.errors }"></ng-select>
+                                <ng-select placeholder="{{'SELECT' | translate}} {{'MGMT' | translate}}" [items]="mgmtState" bindLabel="name" bindValue="value" formControlName="mgmt" id="mgmt{{i}}" [ngClass]="{ 'is-invalid': submitted && params.controls.mgmt.errors }"></ng-select>
                             </div>
                             <label class="col-sm-2 col-form-label padLeft0 padRight0" for="vimNetName{{i}}">{{'NETNAME' | translate}}*</label>
                             <div class="col-sm-4">
diff --git a/src/app/instances/pdu-instances/add-pdu-instances/AddPDUInstancesComponent.ts b/src/app/instances/pdu-instances/add-pdu-instances/AddPDUInstancesComponent.ts
index 0dcbb60..644b83d 100644
--- a/src/app/instances/pdu-instances/add-pdu-instances/AddPDUInstancesComponent.ts
+++ b/src/app/instances/pdu-instances/add-pdu-instances/AddPDUInstancesComponent.ts
@@ -59,9 +59,6 @@
     /** Variable set for twoway binding @public */
     public pduInstanceId: string;
 
-    /** Set mgmt field to empty on load @public */
-    public selectedMgmt: string;
-
     /** Set vim field to empty on load @public */
     public selectedVIM: string;
 
@@ -141,7 +138,7 @@
         return this.formBuilder.group({
             name: ['', [Validators.required]],
             'ip-address': ['', [Validators.required, Validators.pattern(this.sharedService.REGX_IP_PATTERN)]],
-            mgmt: ['', [Validators.required]],
+            mgmt: [null, [Validators.required]],
             'vim-network-name': ['', [Validators.required]]
         });
     }
