diff --git a/app/src/api/cmd.ts b/app/src/api/cmd.ts
index 48090bfa..d4adb3fc 100644
--- a/app/src/api/cmd.ts
+++ b/app/src/api/cmd.ts
@@ -90,7 +90,9 @@ export type Cmd =
   | "GetAwsInstanceTypes"
   | "RestartContainer"
   | "RestartChildSwarmContainers"
-  | "GetSignedInUserDetails";
+  | "GetSignedInUserDetails"
+  | "UpdateAwsInstanceType"
+  | "GetInstanceType";
 
 interface CmdData {
   cmd: Cmd;
diff --git a/app/src/api/swarm.ts b/app/src/api/swarm.ts
index 80b6aaf0..22ccfb82 100644
--- a/app/src/api/swarm.ts
+++ b/app/src/api/swarm.ts
@@ -327,3 +327,24 @@ export async function create_new_swarm_ec2({
 export async function get_aws_instance_types() {
   return await swarmCmd("GetAwsInstanceTypes");
 }
+
+export async function update_aws_instance_type({
+  instance_id,
+  instance_type,
+}: {
+  instance_id: string;
+  instance_type: string;
+}) {
+  return await swarmCmd("UpdateAwsInstanceType", {
+    instance_id,
+    instance_type,
+  });
+}
+
+export async function get_swarm_instance_type({
+  instance_id,
+}: {
+  instance_id: string;
+}) {
+  return await swarmCmd("GetInstanceType", { instance_id });
+}
diff --git a/src/bin/super/cmd.rs b/src/bin/super/cmd.rs
index b28f923c..a840d7d4 100644
--- a/src/bin/super/cmd.rs
+++ b/src/bin/super/cmd.rs
@@ -77,6 +77,8 @@ pub enum SwarmCmd {
     RestartChildSwarmContainers(AccessNodesInfo),
     CreateNewEc2Instance(CreateEc2InstanceInfo),
     GetAwsInstanceTypes,
+    UpdateAwsInstanceType(UpdateInstanceDetails),
+    GetInstanceType(GetInstanceTypeByInstanceId),
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -84,6 +86,12 @@ pub struct ChildSwarmIdentifier {
     pub host: String,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct UpdateInstanceDetails {
+    pub instance_id: String,
+    pub instance_type: String,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct AddSwarmResponse {
     pub success: bool,
@@ -114,3 +122,13 @@ pub struct CreateEc2InstanceInfo {
     pub vanity_address: Option<String>,
     pub instance_type: String,
 }
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct GetInstanceTypeByInstanceId {
+    pub instance_id: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct GetInstanceTypeRes {
+    pub instance_type: Option<String>,
+}
diff --git a/src/bin/super/mod.rs b/src/bin/super/mod.rs
index a80042d0..8abc7d71 100644
--- a/src/bin/super/mod.rs
+++ b/src/bin/super/mod.rs
@@ -1,6 +1,7 @@
 mod auth_token;
 mod checker;
 mod cmd;
+mod route53;
 mod routes;
 mod state;
 mod util;
@@ -11,8 +12,9 @@ use sphinx_swarm::utils::getenv;
 use state::RemoteStack;
 use state::Super;
 use util::{
-    accessing_child_container_controller, add_new_swarm_details, get_aws_instance_types,
-    get_child_swarm_config, get_child_swarm_containers,
+    accessing_child_container_controller, add_new_swarm_details, add_new_swarm_from_child_swarm,
+    get_aws_instance_types, get_child_swarm_config, get_child_swarm_containers,
+    get_swarm_instance_type, update_aws_instance_type,
 };
 
 use crate::checker::swarm_checker;
@@ -171,7 +173,8 @@ pub async fn super_handle(
                     pass: Some("".to_string()),
                     ec2: Some(swarm.instance),
                     note: Some(swarm.description),
-                    default_host: Some("".to_string()),
+                    default_host: "".to_string(),
+                    ec2_instance_id: "".to_string(),
                 };
 
                 let hm = add_new_swarm_details(&mut state, swarm_detail, &mut must_save_stack);
@@ -189,6 +192,7 @@ pub async fn super_handle(
                             user: state.stacks[ui].user.clone(),
                             pass: state.stacks[ui].pass.clone(),
                             default_host: state.stacks[ui].default_host.clone(),
+                            ec2_instance_id: state.stacks[ui].ec2_instance_id.clone(),
                         };
                         must_save_stack = true;
                         hm = AddSwarmResponse {
@@ -228,9 +232,11 @@ pub async fn super_handle(
                     pass: Some(c.password),
                     user: Some(c.username),
                     ec2: Some("".to_string()),
-                    default_host: Some(c.default_host),
+                    default_host: c.default_host,
+                    ec2_instance_id: "".to_string(),
                 };
-                let hm = add_new_swarm_details(&mut state, swarm_details, &mut must_save_stack);
+                let hm =
+                    add_new_swarm_from_child_swarm(&mut state, swarm_details, &mut must_save_stack);
 
                 Some(serde_json::to_string(&hm)?)
             }
@@ -309,8 +315,9 @@ pub async fn super_handle(
             }
             SwarmCmd::CreateNewEc2Instance(info) => {
                 let res: SuperSwarmResponse;
-                match create_swarm_ec2(&info).await {
+                match create_swarm_ec2(&info, &mut state).await {
                     Ok(_) => {
+                        must_save_stack = true;
                         res = SuperSwarmResponse {
                             success: true,
                             message: format!("{} was created successfully", &info.name.clone()),
@@ -328,6 +335,41 @@ pub async fn super_handle(
 
                 Some(serde_json::to_string(&res)?)
             }
+            SwarmCmd::UpdateAwsInstanceType(info) => {
+                let res: SuperSwarmResponse;
+                match update_aws_instance_type(info, &mut state).await {
+                    Ok(_) => {
+                        must_save_stack = true;
+                        res = SuperSwarmResponse {
+                            success: true,
+                            message: "Instance updated successfully".to_string(),
+                            data: None,
+                        }
+                    }
+                    Err(err) => {
+                        res = SuperSwarmResponse {
+                            success: false,
+                            message: err.to_string(),
+                            data: None,
+                        }
+                    }
+                }
+                Some(serde_json::to_string(&res)?)
+            }
+            SwarmCmd::GetInstanceType(info) => {
+                let res: SuperSwarmResponse;
+                match get_swarm_instance_type(info, &state) {
+                    Ok(result) => res = result,
+                    Err(err) => {
+                        res = SuperSwarmResponse {
+                            success: false,
+                            message: err.to_string(),
+                            data: None,
+                        }
+                    }
+                }
+                Some(serde_json::to_string(&res)?)
+            }
         },
     };
 
diff --git a/src/bin/super/route53.rs b/src/bin/super/route53.rs
new file mode 100644
index 00000000..d697e117
--- /dev/null
+++ b/src/bin/super/route53.rs
@@ -0,0 +1,67 @@
+use anyhow::{anyhow, Error};
+use aws_config::meta::region::RegionProviderChain;
+use aws_config::Region;
+use aws_sdk_route53::types::{
+    Change, ChangeAction, ChangeBatch, ResourceRecord, ResourceRecordSet,
+};
+use aws_sdk_route53::Client as Route53Client;
+use aws_smithy_types::retry::RetryConfig;
+use sphinx_swarm::utils::getenv;
+
+pub async fn add_domain_name_to_route53(
+    domain_names: Vec<&str>,
+    public_ip: &str,
+) -> Result<(), Error> {
+    let region = getenv("AWS_S3_REGION_NAME")?;
+    let hosted_zone_id = getenv("ROUTE53_ZONE_ID")?;
+    let region_provider = RegionProviderChain::first_try(Some(Region::new(region)));
+    let config = aws_config::from_env()
+        .region(region_provider)
+        .retry_config(RetryConfig::standard().with_max_attempts(10))
+        .load()
+        .await;
+    let route53_client = Route53Client::new(&config);
+
+    let mut changes = Vec::new();
+
+    for &domain in &domain_names {
+        let resource_record = ResourceRecord::builder().value(public_ip).build()?;
+
+        let resource_record_set = ResourceRecordSet::builder()
+            .name(domain)
+            .r#type("A".into()) // A record for IPv4
+            .ttl(300) // Time-to-live (in seconds)
+            .resource_records(resource_record)
+            .build()
+            .map_err(|err| anyhow!(err.to_string()))?;
+
+        // Create a change request to upsert (create or update) the A record
+        let change = Change::builder()
+            .action(ChangeAction::Upsert)
+            .resource_record_set(resource_record_set)
+            .build()
+            .map_err(|err| anyhow!(err.to_string()))?;
+
+        changes.push(change);
+    }
+
+    let change_batch = ChangeBatch::builder()
+        .set_changes(Some(changes))
+        .build()
+        .map_err(|err| anyhow!(err.to_string()))?;
+
+    let response = route53_client
+        .change_resource_record_sets()
+        .hosted_zone_id(hosted_zone_id)
+        .change_batch(change_batch)
+        .send()
+        .await?;
+
+    log::info!(
+        "Route 53 change status for {:?}: {:?}",
+        domain_names,
+        response.change_info()
+    );
+
+    Ok(())
+}
diff --git a/src/bin/super/state.rs b/src/bin/super/state.rs
index 24c46412..61081c7a 100644
--- a/src/bin/super/state.rs
+++ b/src/bin/super/state.rs
@@ -4,6 +4,8 @@ use serde::{Deserialize, Serialize};
 use sphinx_swarm::config::{Role, User};
 use sphinx_swarm::secrets;
 
+use crate::util::get_descriptive_instance_type;
+
 #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
 pub struct Super {
     pub stacks: Vec<RemoteStack>,
@@ -19,7 +21,8 @@ pub struct RemoteStack {
     pub ec2: Option<String>,
     pub user: Option<String>,
     pub pass: Option<String>,
-    pub default_host: Option<String>,
+    pub default_host: String,
+    pub ec2_instance_id: String,
 }
 
 #[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Default)]
@@ -76,10 +79,11 @@ impl Super {
             .map(|n| RemoteStack {
                 host: n.host.clone(),
                 note: n.note.clone(),
-                ec2: n.ec2.clone(),
+                ec2: Some(get_descriptive_instance_type(n.ec2.clone())),
                 user: None,
                 pass: None,
                 default_host: n.default_host.clone(),
+                ec2_instance_id: n.ec2_instance_id.clone(),
             })
             .collect();
         let bots = self
diff --git a/src/bin/super/superapp/src/Remotes.svelte b/src/bin/super/superapp/src/Remotes.svelte
index 1b4a468f..c05e2432 100644
--- a/src/bin/super/superapp/src/Remotes.svelte
+++ b/src/bin/super/superapp/src/Remotes.svelte
@@ -37,6 +37,7 @@
     update_child_swarm_containers,
     get_aws_instance_types,
     restart_child_swarm_containers,
+    update_aws_instance_type,
   } from "../../../../../app/src/api/swarm";
 
   let open_create_edit = false;
@@ -489,6 +490,10 @@
         vanity_input_width = max_input_with;
         swarm_name_width = max_input_with;
         show_notification = true;
+
+        await getConfig();
+
+        await getConfigSortByUnhealthy();
       } else {
         error_notification = true;
       }
diff --git a/src/bin/super/superapp/src/ViewNodes.svelte b/src/bin/super/superapp/src/ViewNodes.svelte
index dc4865fc..6b585e78 100644
--- a/src/bin/super/superapp/src/ViewNodes.svelte
+++ b/src/bin/super/superapp/src/ViewNodes.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import { ArrowLeft, UpdateNow, Stop } from "carbon-icons-svelte";
-  import { selectedNode } from "./store";
+  import { selectedNode, remotes } from "./store";
   import { onMount } from "svelte";
   import {
     get_child_swarm_config,
@@ -9,6 +9,9 @@
     start_child_swarm_containers,
     stop_child_swarm_containers,
     update_child_swarm_containers,
+    get_aws_instance_types,
+    update_aws_instance_type,
+    get_swarm_instance_type,
   } from "../../../../../app/src/api/swarm";
   import {
     Button,
@@ -21,7 +24,12 @@
     ToolbarMenuItem,
     ToastNotification,
     ToolbarBatchActions,
+    Modal,
+    InlineNotification,
+    Select,
+    SelectItem,
   } from "carbon-components-svelte";
+  import type { Remote } from "./types/types";
 
   let loading = true;
   let selectedRowIds = [];
@@ -32,6 +40,13 @@
   $: sortedNodes = [];
   $: nodes_to_be_modified = [];
   let show_notification = false;
+  let aws_instance_types = [];
+  let current_instance_type = "";
+  let node: Remote | null = null;
+  let open_update_instance_type = false;
+  let isSubmitting = false;
+  let error_notification = false;
+  let selected_instance = "";
 
   async function setupNodes() {
     const result = await get_child_swarm_config({ host: $selectedNode });
@@ -72,9 +87,86 @@
     loading = false;
   }
 
+  async function getAwsInstanceType() {
+    try {
+      const instanceTypes = await get_aws_instance_types();
+      if (instanceTypes.success) {
+        aws_instance_types = [...instanceTypes.data];
+      }
+    } catch (error) {
+      console.log("Error getting AWS Instance Type: ", error);
+    }
+  }
+
+  async function get_current_service_details() {
+    for (let i = 0; i < $remotes.length; i++) {
+      const remote = $remotes[i];
+      if (remote.host === remote.host) {
+        node = { ...remote };
+        try {
+          const response = await get_swarm_instance_type({
+            instance_id: remote.ec2_instance_id,
+          });
+          if (response.success) {
+            current_instance_type = response.data.instance_type;
+          }
+        } catch (error) {
+          console.log("ERORR GETTING SWARM INSTANCE TYPE: ", error);
+        }
+        return;
+      }
+    }
+  }
+
+  function handleOpenUpdateInstanceType() {
+    selected_instance = current_instance_type;
+    open_update_instance_type = true;
+  }
+
+  async function handleSubmitNewInstanceType() {
+    isSubmitting = true;
+    if (!node || !node.ec2_instance_id) {
+      error_notification = true;
+      message = "Can't edit this instance type currently";
+      isSubmitting = false;
+      return;
+    }
+    try {
+      const result = await update_aws_instance_type({
+        instance_id: node.ec2_instance_id,
+        instance_type: selected_instance,
+      });
+
+      message = result.message;
+      if (result.success) {
+        errorMessage = false;
+        show_notification = true;
+        // close modal
+        open_update_instance_type = false;
+        current_instance_type = selected_instance;
+      } else {
+        error_notification = true;
+      }
+    } catch (error) {
+      console.log("ERROR EDITING INSTANCE TYPE: ", JSON.stringify(error));
+    } finally {
+      isSubmitting = false;
+    }
+  }
+
+  function handleOnCloseUpdateInstanceType() {
+    selected_instance = current_instance_type;
+    isSubmitting = false;
+    open_update_instance_type = false;
+  }
+
   onMount(async () => {
     // get internal node for this service
-    setupNodes();
+    await setupNodes();
+
+    await getAwsInstanceType();
+
+    await get_current_service_details();
   });
 
   function findContainer(node_name: string) {
@@ -321,6 +413,10 @@
             <ToolbarMenuItem on:click={() => upgradeAllContainer()} hasDivider
               >Upgrade All</ToolbarMenuItem
             >
+            <ToolbarMenuItem
+              on:click={() => handleOpenUpdateInstanceType()}
+              hasDivider>Update Instance Type</ToolbarMenuItem
+            >
           </ToolbarMenu>
         </ToolbarContent>
       </Toolbar>
@@ -352,6 +448,45 @@
         {/if}
       </svelte:fragment>
     </DataTable>
+    <Modal
+      bind:open={open_update_instance_type}
+      modalHeading="Update Ec2 Instance Type"
+      primaryButtonDisabled={selected_instance === current_instance_type ||
+        !selected_instance ||
+        isSubmitting}
+      primaryButtonText={isSubmitting ? "Loading..." : "Update"}
+      secondaryButtonText="Cancel"
+      on:click:button--secondary={() => (open_update_instance_type = false)}
+      on:open
+      on:close={handleOnCloseUpdateInstanceType}
+      on:submit={handleSubmitNewInstanceType}
+    >
+      {#if error_notification}
+        <InlineNotification
+          kind="error"
+          title="Error:"
+          subtitle={message}
+          timeout={3000}
+          on:close={(e) => {
+            e.preventDefault();
+            error_notification = false;
+          }}
+        />
+      {/if}
+      <div class="select_instance_container">
+        <Select
+          on:change={(e) => (selected_instance = e.target.value)}
+          helperText="Select Ec2 Instance Size"
+          labelText="Ec2 Instance Size"
+          selected={selected_instance}
+        >
+          <SelectItem value={""} text={"Select Size"} />
+          {#each aws_instance_types as option}
+            <SelectItem value={option.value} text={option.name} />
+          {/each}
+        </Select>
+      </div>
+    </Modal>
   {/if}
 </main>
 
diff --git a/src/bin/super/superapp/src/types/types.ts b/src/bin/super/superapp/src/types/types.ts
index b5555ad2..7da07a9b 100644
--- a/src/bin/super/superapp/src/types/types.ts
+++ b/src/bin/super/superapp/src/types/types.ts
@@ -35,4 +35,5 @@ export interface Remote {
   note?: string;
   ec2?: string;
   default_host?: string;
+  ec2_instance_id: string;
 }
diff --git a/src/bin/super/superapp/src/utils/index.ts b/src/bin/super/superapp/src/utils/index.ts
index d5cb5e48..2a54315d 100644
--- a/src/bin/super/superapp/src/utils/index.ts
+++ b/src/bin/super/superapp/src/utils/index.ts
@@ -38,3 +38,9 @@ export function isValidVanityAddress(vanity_address: string) {
 
   return "";
 }
+
+export function extract_instance_type(instance_type: string) {
+  const split_array = instance_type.split(" ");
+  const temp_instance = split_array[1];
+  return temp_instance.slice(1, temp_instance.length - 1);
+}
diff --git a/src/bin/super/util.rs b/src/bin/super/util.rs
index 64665682..0d6e5b37 100644
--- a/src/bin/super/util.rs
+++ b/src/bin/super/util.rs
@@ -4,12 +4,11 @@ use std::str::FromStr;
 use anyhow::{anyhow, Error};
 use aws_config::meta::region::RegionProviderChain;
 use aws_config::Region;
-use aws_sdk_ec2::types::{BlockDeviceMapping, EbsBlockDevice, InstanceType, Tag, TagSpecification};
-use aws_sdk_ec2::Client;
-use aws_sdk_route53::types::{
-    Change, ChangeAction, ChangeBatch, ResourceRecord, ResourceRecordSet,
+use aws_sdk_ec2::client::Waiters;
+use aws_sdk_ec2::types::{
+    AttributeValue, BlockDeviceMapping, EbsBlockDevice, InstanceType, Tag, TagSpecification,
 };
-use aws_sdk_route53::Client as Route53Client;
+use aws_sdk_ec2::Client;
 use aws_smithy_types::retry::RetryConfig;
 use futures_util::TryFutureExt;
 use reqwest::Response;
@@ -19,8 +18,10 @@ use sphinx_swarm::config::Stack;
 use sphinx_swarm::utils::{getenv, make_reqwest_client};
 
 use crate::cmd::{
-    AccessNodesInfo, AddSwarmResponse, CreateEc2InstanceInfo, LoginResponse, SuperSwarmResponse,
+    AccessNodesInfo, AddSwarmResponse, CreateEc2InstanceInfo, GetInstanceTypeByInstanceId,
+    GetInstanceTypeRes, LoginResponse, SuperSwarmResponse, UpdateInstanceDetails,
 };
+use crate::route53::add_domain_name_to_route53;
 use crate::state::{AwsInstanceType, RemoteStack, Super};
 use rand::Rng;
 use tokio::time::{sleep, Duration};
@@ -48,6 +49,47 @@ pub fn add_new_swarm_details(
     }
 }
 
+pub fn add_new_swarm_from_child_swarm(
+    state: &mut Super,
+    swarm_details: RemoteStack,
+    must_save_stack: &mut bool,
+) -> AddSwarmResponse {
+    match state
+        .stacks
+        .iter()
+        .position(|swarm| swarm.default_host == swarm_details.default_host)
+    {
+        Some(swarm_pos) => {
+            if let Some(password) = &state.stacks[swarm_pos].pass {
+                if !password.is_empty() {
+                    return AddSwarmResponse {
+                        success: false,
+                        message: "swarm already exist".to_string(),
+                    };
+                }
+            }
+
+            state.stacks[swarm_pos].host = swarm_details.host;
+            state.stacks[swarm_pos].pass = swarm_details.pass;
+            state.stacks[swarm_pos].user = swarm_details.user;
+
+            *must_save_stack = true;
+            return AddSwarmResponse {
+                success: true,
+                message: "Swarm added successfully".to_string(),
+            };
+        }
+        None => {
+            state.add_remote_stack(swarm_details);
+            *must_save_stack = true;
+            return AddSwarmResponse {
+                success: true,
+                message: "Swarm added successfully".to_string(),
+            };
+        }
+    }
+}
+
 pub async fn login_to_child_swarm(swarm_details: &RemoteStack) -> Result<String, Error> {
     let client = make_reqwest_client();
 
@@ -112,20 +154,20 @@ pub async fn get_child_swarm_config(
     })
 }
 
-async fn swarm_cmd(cmd: Cmd, host: Option<String>, token: &str) -> Result<Response, Error> {
+async fn swarm_cmd(cmd: Cmd, host: String, token: &str) -> Result<Response, Error> {
     let url = get_child_base_route(host)?;
     let cmd_res = send_cmd_request(cmd, "SWARM", &url, Some("x-jwt"), Some(&token)).await?;
     Ok(cmd_res)
 }
 
-pub fn get_child_base_route(host: Option<String>) -> Result<String, Error> {
-    if host.is_none() {
+pub fn get_child_base_route(host: String) -> Result<String, Error> {
+    if host.is_empty() {
         return Err(anyhow!("child swarm default host not provided"));
     };
 
-    return Ok(format!("https://app.{}/api", host.unwrap()));
+    return Ok(format!("https://app.{}/api", host));
 
-    // return Ok(format!("http://{}/api", host.unwrap()));
+    // return Ok(format!("http://{}/api", host));
 }
 
 pub async fn get_child_swarm_containers(
@@ -244,8 +286,8 @@ pub async fn accessing_child_container_controller(
     res
 }
 
-pub fn get_aws_instance_types() -> SuperSwarmResponse {
-    let instance_types: Vec<AwsInstanceType> = vec![
+fn instance_types() -> Vec<AwsInstanceType> {
+    return vec![
         AwsInstanceType {
             name: "Large".to_string(),
             value: "m5.large".to_string(),
@@ -259,6 +301,10 @@ pub fn get_aws_instance_types() -> SuperSwarmResponse {
             value: "g4dn.2xlarge".to_string(),
         },
     ];
+}
+
+pub fn get_aws_instance_types() -> SuperSwarmResponse {
+    let instance_types = instance_types();
 
     match serde_json::to_value(instance_types) {
         Ok(instance_value) => SuperSwarmResponse {
@@ -274,6 +320,25 @@ pub fn get_aws_instance_types() -> SuperSwarmResponse {
     }
 }
 
+pub fn get_descriptive_instance_type(instance_value: Option<String>) -> String {
+    if let None = &instance_value {
+        return "".to_string();
+    }
+
+    let instance_types = instance_types();
+
+    match instance_types
+        .iter()
+        .position(|instance| instance.value == instance_value.clone().unwrap())
+    {
+        Some(instance_pos) => {
+            let instance = &instance_types[instance_pos];
+            format!("{} ({})", instance.name, instance.value)
+        }
+        None => "".to_string(),
+    }
+}
+
 async fn create_ec2_instance(
     swarm_name: String,
     vanity_address: Option<String>,
@@ -507,57 +572,11 @@ async fn get_instance_ip(instance_id: &str) -> Result<String, Error> {
     Ok(public_ip_address.to_string())
 }
 
-async fn add_domain_name_to_route53(domain_name: &str, public_ip: &str) -> Result<(), Error> {
-    let region = getenv("AWS_S3_REGION_NAME")?;
-    let hosted_zone_id = getenv("ROUTE53_ZONE_ID")?;
-    let region_provider = RegionProviderChain::first_try(Some(Region::new(region)));
-    let config = aws_config::from_env()
-        .region(region_provider)
-        .retry_config(RetryConfig::standard().with_max_attempts(10))
-        .load()
-        .await;
-    let route53_client = Route53Client::new(&config);
-
-    let resource_record = ResourceRecord::builder().value(public_ip).build()?;
-
-    let resource_record_set = ResourceRecordSet::builder()
-        .name(domain_name)
-        .r#type("A".into()) // A record for IPv4
-        .ttl(300) // Time-to-live (in seconds)
-        .resource_records(resource_record)
-        .build()
-        .map_err(|err| anyhow!(err.to_string()))?;
-
-    // Create a change request to upsert (create or update) the A record
-    let change = Change::builder()
-        .action(ChangeAction::Upsert)
-        .resource_record_set(resource_record_set)
-        .build()
-        .map_err(|err| anyhow!(err.to_string()))?;
-
-    let change_batch = ChangeBatch::builder()
-        .changes(change)
-        .build()
-        .map_err(|err| anyhow!(err.to_string()))?;
-
-    let response = route53_client
-        .change_resource_record_sets()
-        .hosted_zone_id(hosted_zone_id)
-        .change_batch(change_batch)
-        .send()
-        .await?;
-
-    log::info!(
-        "Route 53 change status for {}: {:?}",
-        domain_name,
-        response.change_info()
-    );
-
-    Ok(())
-}
-
 //Sample execution function
-pub async fn create_swarm_ec2(info: &CreateEc2InstanceInfo) -> Result<(), Error> {
+pub async fn create_swarm_ec2(
+    info: &CreateEc2InstanceInfo,
+    state: &mut Super,
+) -> Result<(), Error> {
     if let Some(vanity_address) = &info.vanity_address {
         if !vanity_address.is_empty() {
             if let Some(subdomain) = vanity_address.strip_suffix(".sphinx.chat") {
@@ -570,7 +589,7 @@ pub async fn create_swarm_ec2(info: &CreateEc2InstanceInfo) -> Result<(), Error>
             }
         }
     }
-    let ec2_intance_id = create_ec2_instance(
+    let ec2_intance = create_ec2_instance(
         info.name.clone(),
         info.vanity_address.clone(),
         info.instance_type.clone(),
@@ -579,18 +598,40 @@ pub async fn create_swarm_ec2(info: &CreateEc2InstanceInfo) -> Result<(), Error>
 
     sleep(Duration::from_secs(40)).await;
 
-    let ec2_ip_address = get_instance_ip(&ec2_intance_id.0).await?;
-    let _ = add_domain_name_to_route53(
-        &format!("*.swarm{}.sphinx.chat", &ec2_intance_id.1),
-        &ec2_ip_address,
-    )
-    .await?;
+    let default_host = format!("swarm{}.sphinx.chat", &ec2_intance.1);
+
+    let ec2_ip_address = get_instance_ip(&ec2_intance.0).await?;
+    let default_domain = format!("*.{}", default_host);
+    let mut domain_names = vec![default_domain.as_str()];
+
+    let mut host = default_host.clone();
+
     if let Some(custom_domain) = &info.vanity_address {
         log::info!("vanity address is being set");
-        let _custom_domain_result =
-            add_domain_name_to_route53(custom_domain, &ec2_ip_address).await?;
+        if !custom_domain.is_empty() {
+            host = custom_domain.clone();
+            domain_names.push(custom_domain.as_str());
+        }
     }
+
+    let _ = add_domain_name_to_route53(domain_names, &ec2_ip_address).await?;
+
     log::info!("Public_IP: {}", ec2_ip_address);
+
+    // add new ec2 to list of swarms
+    let new_swarm = RemoteStack {
+        host: host,
+        ec2: Some(info.instance_type.clone()),
+        default_host: default_host,
+        note: Some("".to_string()),
+        user: Some("".to_string()),
+        pass: Some("".to_string()),
+        ec2_instance_id: ec2_intance.0,
+    };
+
+    state.add_remote_stack(new_swarm);
+
+    log::info!("New Swarm added to stack");
     Ok(())
 }
 
@@ -618,3 +659,176 @@ fn is_valid_domain(domain: String) -> String {
 
     "".to_string()
 }
+
+pub async fn update_aws_instance_type(
+    details: UpdateInstanceDetails,
+    state: &mut Super,
+) -> Result<(), Error> {
+    if details.instance_id.is_empty() {
+        return Err(anyhow!("Please provide a valid instance id"));
+    }
+
+    if details.instance_type.is_empty() {
+        return Err(anyhow!("Please provide a instance type"));
+    }
+
+    // find instance type
+    let instance_types = instance_types();
+    if let None = instance_types
+        .iter()
+        .position(|instance_type| instance_type.value == details.instance_type)
+    {
+        return Err(anyhow!("Invalid instance type"));
+    }
+
+    let swarm_pos = state
+        .stacks
+        .iter()
+        .position(|swarm| swarm.ec2_instance_id == details.instance_id);
+
+    if let None = swarm_pos {
+        return Err(anyhow!("Instance does not exist"));
+    }
+    let unwrapped_swarm_pos = swarm_pos.unwrap();
+
+    if let Some(current_instance) = &state.stacks[unwrapped_swarm_pos].ec2 {
+        if details.instance_type == current_instance.to_string() {
+            return Err(anyhow!("Please select a different instance type"));
+        }
+    }
+
+    let ec2_instance_id = state.stacks[unwrapped_swarm_pos].ec2_instance_id.clone();
+
+    let client = make_aws_client().await?;
+
+    //update ec2 instance type
+    update_ec2_instance_type(&client, &ec2_instance_id, &details.instance_type).await?;
+
+    // get ec2 instance ip
+    let new_ec2_ip_address = get_instance_ip(&details.instance_id).await?;
+
+    let current_swarm: &RemoteStack = &state.stacks[unwrapped_swarm_pos];
+
+    let defailt_domain = format!("*.{}", current_swarm.default_host.clone());
+
+    let mut domain_names = vec![defailt_domain.as_str()];
+
+    if current_swarm.default_host.clone() != current_swarm.host {
+        domain_names.push(&current_swarm.host)
+    }
+
+    //update route53 record for both host and default_host
+    let _ = add_domain_name_to_route53(domain_names, &new_ec2_ip_address).await?;
+
+    // update stack with current instance type locally
+    state.stacks[unwrapped_swarm_pos].ec2 = Some(details.instance_type);
+    Ok(())
+}
+
+pub async fn stop_ec2_instance(client: &Client, instance_id: &str) -> Result<(), Error> {
+    log::info!("Stopping instance: {}", instance_id);
+
+    client
+        .stop_instances()
+        .instance_ids(instance_id)
+        .send()
+        .await?;
+
+    log::info!("Waiting for instance to stop...");
+
+    client
+        .wait_until_instance_stopped()
+        .instance_ids(instance_id)
+        .wait(Duration::from_secs(120))
+        .await?;
+
+    log::info!("Instance Stopped...");
+    Ok(())
+}
+
+pub async fn start_ec2_instance(client: &Client, instance_id: &str) -> Result<(), Error> {
+    client
+        .start_instances()
+        .instance_ids(instance_id)
+        .send()
+        .await?;
+
+    log::info!("Waiting for instance to be running");
+
+    client
+        .wait_until_instance_running()
+        .instance_ids(instance_id)
+        .wait(Duration::from_secs(120))
+        .await?;
+
+    log::info!("Started instance successfully");
+    Ok(())
+}
+
+pub async fn update_ec2_instance_type(
+    client: &Client,
+    instance_id: &str,
+    instance_type: &str,
+) -> Result<(), Error> {
+    // stop ec2 instance
+    stop_ec2_instance(client, &instance_id).await?;
+
+    log::info!("Modifying Ec2 Instance...");
+    // update ec2 instance
+    client
+        .modify_instance_attribute()
+        .instance_id(instance_id)
+        .instance_type(
+            AttributeValue::builder()
+                .set_value(Some(instance_type.to_string()))
+                .build(),
+        )
+        .send()
+        .await?;
+
+    // state ec2 instance
+    start_ec2_instance(&client, instance_id).await?;
+    Ok(())
+}
+
+async fn make_aws_client() -> Result<Client, Error> {
+    let region = getenv("AWS_S3_REGION_NAME")?;
+    let region_provider = RegionProviderChain::first_try(Some(Region::new(region)));
+    let config = aws_config::from_env()
+        .region(region_provider)
+        .retry_config(RetryConfig::standard().with_max_attempts(10))
+        .load()
+        .await;
+
+    Ok(Client::new(&config))
+}
+
+pub fn get_swarm_instance_type(
+    info: GetInstanceTypeByInstanceId,
+    state: &Super,
+) -> Result<SuperSwarmResponse, Error> {
+    if info.instance_id.is_empty() {
+        return Err(anyhow!("Please provide a valid instance id"));
+    }
+
+    let swarm_pos = state
+        .stacks
+        .iter()
+        .position(|swarm| swarm.ec2_instance_id == info.instance_id);
+
+    if swarm_pos.is_none() {
+        return Err(anyhow!("Swarm does not exist"));
+    };
+
+    let instance_res = GetInstanceTypeRes {
+        instance_type: state.stacks[swarm_pos.unwrap()].ec2.clone(),
+    };
+
+    let value = serde_json::to_value(instance_res)?;
+
+    return Ok(SuperSwarmResponse {
+        success: true,
+        message: "instance type".to_string(),
+        data: Some(value),
+    });
+}
diff --git a/src/defaults.rs b/src/defaults.rs
index 87d14c61..3bb6f683 100644
--- a/src/defaults.rs
+++ b/src/defaults.rs
@@ -33,6 +33,10 @@ impl Default for Stack {
             host = None
         }
 
+        if env_is_true("CHATUI_ONLY") {
+            return only_local_chat_ui();
+        }
+
         if env_is_true("SPHINXV1") {
             return sphinxv1_only(&network, host);
         }
diff --git a/src/images/llama.rs b/src/images/llama.rs
index 8a017260..298cb936 100644
--- a/src/images/llama.rs
+++ b/src/images/llama.rs
@@ -1,7 +1,7 @@
 use super::traefik::traefik_labels;
 use super::*;
 use crate::config::Node;
-use crate::utils::{add_gpus_to_host_config, domain, exposed_ports, host_config};
+use crate::utils::{add_gpus_to_host_config, domain, exposed_ports, getenv, host_config};
 use anyhow::Result;
 use async_trait::async_trait;
 use bollard::container::Config;
@@ -20,7 +20,7 @@ pub struct LlamaImage {
 }
 
 // https://huggingface.co/TheBloke/Llama-2-7B-GGUF
-const DEFAULT_MODEL: &str = "models/llama-2-7b.Q4_K_M.gguf";
+const DEFAULT_MODEL: &str = "llama-2-7b.Q4_K_M.gguf";
 const VERSION: &str = "server-cuda";
 
 impl LlamaImage {
@@ -37,6 +37,9 @@ impl LlamaImage {
     pub fn set_pwd(&mut self, pwd: &str) {
         self.pwd = Some(pwd.to_string());
     }
+    pub fn model(&mut self, model: &str) {
+        self.model = model.to_string();
+    }
     pub fn host(&mut self, eh: Option<String>) {
         if let Some(h) = eh {
             self.host = Some(format!("{}.{}", self.name, h));
@@ -78,7 +81,7 @@ fn llama(img: &LlamaImage) -> Result<Config<String>> {
 
     let ports = vec![img.port.clone()];
 
-    let model_path = format!("/{}", img.model);
+    let model_path = format!("/models/{}", img.model);
     let env = vec![
         format!("LLAMA_ARG_PORT={}", img.port),
         format!("LLAMA_ARG_MODEL={}", model_path),
@@ -92,14 +95,21 @@ fn llama(img: &LlamaImage) -> Result<Config<String>> {
             cwd.to_string_lossy().to_string()
         }
     };
-    let model_vol = format!("{}/{}:/{}", pwd, img.model, model_path);
+    let model_vol = format!("{}/models/{}:{}", pwd, img.model, model_path);
     log::info!("model_vol: {}", model_vol);
     let extra_vols = vec![model_vol];
 
     let mut hc = host_config(&img.name, ports.clone(), root_vol, Some(extra_vols), None).unwrap();
     add_gpus_to_host_config(&mut hc, 1);
+
+    let mut version = VERSION;
+    if let Ok(lcput) = getenv("LLAMA_CPU_TEST") {
+        if lcput == "true" {
+            version = "server";
+        }
+    }
     let mut c = Config {
-        image: Some(format!("{}:{}", image, VERSION)),
+        image: Some(format!("{}:{}", image, version)),
         hostname: Some(domain(&img.name)),
         exposed_ports: exposed_ports(ports.clone()),
         host_config: Some(hc),
diff --git a/src/secondbrain.rs b/src/secondbrain.rs
index e3a9c179..997be63b 100644
--- a/src/secondbrain.rs
+++ b/src/secondbrain.rs
@@ -95,18 +95,38 @@ pub fn external_lnd() -> Option<ExternalLnd> {
     None
 }
 
-pub fn only_chat_ui() -> Stack {
+/*
+localtest:
+export CHATUI_ONLY=true
+llama-server --hf-repo microsoft/Phi-3-mini-4k-instruct-gguf --hf-file Phi-3-mini-4k-instruct-q4.gguf -c 4096
+*/
+pub fn only_local_chat_ui() -> Stack {
+    println!("only_local_chat_ui");
+    // let mut llamacpp = crate::images::llama::LlamaImage::new("llama", "8080");
+    // llamacpp.model("Phi-3-mini-4k-instruct-q4.gguf");
     let mongo = crate::images::mongo::MongoImage::new("mongo", "latest");
     let mut chat = crate::images::chat::ChatImage::new("chat-ui", "sha-165b40b");
     chat.links(vec!["mongo"]);
     let nodes = vec![
+        // Node::Internal(Image::Llama(llamacpp)),
         Node::Internal(Image::Mongo(mongo)),
         Node::Internal(Image::Chat(chat)),
     ];
-    return Stack {
-        network: "regtest".to_string(),
+    return default_local_stack(None, "regtest", nodes);
+}
+
+pub fn default_local_stack(host: Option<String>, network: &str, nodes: Vec<Node>) -> Stack {
+    Stack {
+        network: network.to_string(),
         nodes,
+        host,
+        users: vec![Default::default()],
         jwt_key: secrets::random_word(16),
-        ..Default::default()
-    };
+        ready: false,
+        ip: None,
+        auto_update: None,
+        custom_2b_domain: None,
+        global_mem_limit: None,
+        backup_services: None,
+    }
 }