diff --git a/jumpscale/entry_points/threebot.py b/jumpscale/entry_points/threebot.py
index 259b2155a2..9375aec39e 100644
--- a/jumpscale/entry_points/threebot.py
+++ b/jumpscale/entry_points/threebot.py
@@ -11,6 +11,7 @@
 from jumpscale.loader import j
 from jumpscale.threesdk.identitymanager import IdentityManager
 from jumpscale.sals.nginx.nginx import PORTS
+from jumpscale.packages.admin.actors.wallet import Wallet
 
 SERVICES_PORTS = {"nginx": 8999, "nginx_http": 80, "nginx_https": 443, "gedis": 16000}
 
@@ -80,6 +81,9 @@ def start(identity=None, background=False, local=False, development=False, domai
         identity (str, optional): threebot name. Defaults to None.
         explorer (str, optional): which explorer network to use: mainnet, testnet, devnet. Defaults to None.
     """
+    if j.config.get("ANNOUNCED") is None:
+        j.config.set("ANNOUNCED", False)
+    create_wallets_if_not_exists()
     check_for_bins()
     PORTS.init_default_ports(local)
     SERVICES_PORTS["nginx_http"] = PORTS.HTTP
@@ -227,7 +231,7 @@ def clean(all=False):
                 print(f"exception was {e} for debugging")
 
             answer = j.tools.console.ask_yes_no(f"Do you want to remove {config_root} ? ")
-            if answer=="y":
+            if answer == "y":
                 j.sals.fs.rmtree(config_root)
                 print("Previous configuration is deleted.")
 
@@ -236,12 +240,44 @@ def clean(all=False):
             print(f"exception for debugging {e}")
 
 
-
 @click.group()
 def cli():
     pass
 
 
+def have_wallets():
+    wallets = j.clients.stellar.list_all()
+    test, main = False, False
+    for wallet_name in wallets:
+        wallet = j.clients.stellar.get(wallet_name)
+        if wallet.network.value == "TEST":
+            test = True
+        elif wallet.network.value == "STD":
+            main = True
+    return test, main
+
+
+def create_test_wallet(wallet_name):
+    try:
+        j.clients.stellar.create_testnet_funded_wallet(wallet_name)
+    except Exception as e:
+        j.logger.error(str(e))
+
+
+def create_main_wallet(wallet_name):
+    wallet_actor = Wallet()
+    try:
+        wallet_actor.create_wallet(wallet_name, "STD")
+    except Exception as e:
+        j.logger.error(str(e))
+
+
+def create_wallets_if_not_exists():
+    test, main = have_wallets()
+    if not test:
+        create_test_wallet("test")
+    if not main:
+        create_main_wallet("main")
 
 
 cli.add_command(start)
diff --git a/jumpscale/packages/admin/actors/admin.py b/jumpscale/packages/admin/actors/admin.py
index f06725881e..5626485b35 100644
--- a/jumpscale/packages/admin/actors/admin.py
+++ b/jumpscale/packages/admin/actors/admin.py
@@ -185,6 +185,8 @@ def get_developer_options(self) -> str:
         test_cert = j.core.config.set_default("TEST_CERT", False)
         over_provision = j.core.config.set_default("OVER_PROVISIONING", False)
         explorer_logs = j.core.config.set_default("EXPLORER_LOGS", False)
+        escalation_emails = j.core.config.set_default("ESCALATION_EMAILS_ENABLED", False)
+        auto_extend_pools = j.core.config.set_default("AUTO_EXTEND_POOLS_ENABLED", False)
         sort_nodes_by_sru = j.core.config.set_default("SORT_NODES_BY_SRU", False)
         return j.data.serializers.json.dumps(
             {
@@ -192,6 +194,8 @@ def get_developer_options(self) -> str:
                     "test_cert": test_cert,
                     "over_provision": over_provision,
                     "explorer_logs": explorer_logs,
+                    "escalation_emails": escalation_emails,
+                    "auto_extend_pools": auto_extend_pools,
                     "sort_nodes_by_sru": sort_nodes_by_sru,
                 }
             }
@@ -199,11 +203,19 @@ def get_developer_options(self) -> str:
 
     @actor_method
     def set_developer_options(
-        self, test_cert: bool, over_provision: bool, explorer_logs: bool, sort_nodes_by_sru: bool
+        self,
+        test_cert: bool,
+        over_provision: bool,
+        explorer_logs: bool,
+        sort_nodes_by_sru: bool,
+        escalation_emails: bool,
+        auto_extend_pools: bool,
     ) -> str:
         j.core.config.set("TEST_CERT", test_cert)
         j.core.config.set("OVER_PROVISIONING", over_provision)
         j.core.config.set("EXPLORER_LOGS", explorer_logs)
+        j.core.config.set("ESCALATION_EMAILS_ENABLED", escalation_emails)
+        j.core.config.set("AUTO_EXTEND_POOLS_ENABLED", auto_extend_pools)
         j.core.config.set("SORT_NODES_BY_SRU", sort_nodes_by_sru)
         return j.data.serializers.json.dumps(
             {
@@ -211,6 +223,8 @@ def set_developer_options(
                     "test_cert": test_cert,
                     "over_provision": over_provision,
                     "explorer_logs": explorer_logs,
+                    "escalation_emails": escalation_emails,
+                    "auto_extend_pools": auto_extend_pools,
                     "sort_nodes_by_sru": sort_nodes_by_sru,
                 }
             }
@@ -222,6 +236,42 @@ def clear_blocked_nodes(self) -> str:
         return j.data.serializers.json.dumps({"data": "blocked nodes got cleared successfully."})
 
     @actor_method
+    def get_email_server_config(self) -> str:
+        email_server_config = j.core.config.get("EMAIL_SERVER_CONFIG", {})
+        email_server_config.setdefault("host", "")
+        email_server_config.setdefault("port", "")
+        email_server_config.setdefault("username", "")
+        email_server_config.setdefault("password", "")
+        return j.data.serializers.json.dumps({"data": email_server_config})
+
+    @actor_method
+    def set_email_server_config(self, host="", port="", username="", password="") -> str:
+        email_server_config = j.core.config.get("EMAIL_SERVER_CONFIG", {})
+        email_server_config = {"host": host, "port": port, "username": username, "password": password}
+        j.core.config.set("EMAIL_SERVER_CONFIG", email_server_config)
+        return j.data.serializers.json.dumps({"data": email_server_config})
+
+    @actor_method
+    def list_escalation_emails(self) -> str:
+        escalation_emails = j.core.config.get("ESCALATION_EMAILS", [])
+        return j.data.serializers.json.dumps({"data": escalation_emails})
+
+    @actor_method
+    def add_escalation_email(self, email) -> str:
+        escalation_emails = j.core.config.get("ESCALATION_EMAILS", [])
+        if email not in escalation_emails:
+            escalation_emails.append(email)
+            j.core.config.set("ESCALATION_EMAILS", escalation_emails)
+        return j.data.serializers.json.dumps({"data": escalation_emails})
+
+    @actor_method
+    def delete_escalation_email(self, email) -> str:
+        escalation_emails = j.core.config.get("ESCALATION_EMAILS", [])
+        if email in escalation_emails:
+            escalation_emails.remove(email)
+            j.core.config.set("ESCALATION_EMAILS", escalation_emails)
+        return j.data.serializers.json.dumps({"data": escalation_emails})
+
     def get_notifications(self) -> str:
         notifications = []
         if j.tools.notificationsqueue.count() >= 10:
diff --git a/jumpscale/packages/admin/actors/wallet.py b/jumpscale/packages/admin/actors/wallet.py
index 03f3884648..b92fdec7c5 100644
--- a/jumpscale/packages/admin/actors/wallet.py
+++ b/jumpscale/packages/admin/actors/wallet.py
@@ -5,11 +5,13 @@
 
 class Wallet(BaseActor):
     @actor_method
-    def create_wallet(self, name: str) -> str:
+    def create_wallet(self, name: str, wallettype: str = None) -> str:
         explorer = j.core.identity.me.explorer
-        wallettype = "STD"
-        if "testnet" in explorer.url or "devnet" in explorer.url:
-            wallettype = "TEST"
+        if wallettype is None:
+            if "testnet" in explorer.url or "devnet" in explorer.url:
+                wallettype = "TEST"
+            else:
+                wallettype = "STD"
 
         if j.clients.stellar.find(name):
             raise j.exceptions.Value(f"Wallet {name} already exists")
diff --git a/jumpscale/packages/admin/bottle/admin.py b/jumpscale/packages/admin/bottle/admin.py
index b34bf27853..579e9f4bd8 100644
--- a/jumpscale/packages/admin/bottle/admin.py
+++ b/jumpscale/packages/admin/bottle/admin.py
@@ -8,6 +8,7 @@
 
 app = Bottle()
 
+
 @app.route("/api/allowed", method="GET")
 @login_required
 def allowed():
@@ -44,4 +45,23 @@ def accept():
         )
 
 
+@app.route("/api/announced", method="GET")
+@login_required
+def announced():
+    result = bool(j.config.get("ANNOUNCED"))
+
+    return HTTPResponse(
+        j.data.serializers.json.dumps({"announced": result}), status=200, headers={"Content-Type": "application/json"}
+    )
+
+
+@app.route("/api/announce", method="GET")
+@login_required
+def announce():
+    j.config.set("ANNOUNCED", True)
+    return HTTPResponse(
+        j.data.serializers.json.dumps({"announced": True}), status=200, headers={"Content-Type": "application/json"}
+    )
+
+
 app = SessionMiddleware(app, SESSION_OPTS)
diff --git a/jumpscale/packages/admin/frontend/App.vue b/jumpscale/packages/admin/frontend/App.vue
index 9f5ff42843..e00417cfe2 100644
--- a/jumpscale/packages/admin/frontend/App.vue
+++ b/jumpscale/packages/admin/frontend/App.vue
@@ -136,6 +136,33 @@
       <identities v-model="dialogs.identity"></identities>
       <popup></popup>
     </v-main>
+     <v-dialog
+      v-model="announcement_dialog"
+      persistent
+      max-width="500"
+    >
+
+      <v-card>
+        <v-card-title class="headline">
+          Quick start guide
+        </v-card-title>
+        <v-card-text>
+        We've created two wallets for you; main and test. These are to be used for mainnet and testnet respectively. Make sure your wallets are funded to extend your 3Bots before they expire.
+        <br />
+        Please visit the <a href="https://manual.threefold.io">manual</a> for more information.
+        </v-card-text>
+        <v-card-actions>
+          <v-spacer></v-spacer>
+          <v-btn
+            color="green darken-1"
+            text
+            @click="announced = true"
+          >
+            Ok
+          </v-btn>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
   </v-app>
 </template>
 
@@ -171,14 +198,17 @@ module.exports = {
       dialogs: {
         identity: false,
       },
+      announced: true
     };
   },
   components: {
     identities: httpVueLoader("./Identity.vue"),
   },
-  computed: {},
   methods: {},
   computed: {
+    announcement_dialog() {
+      return !this.announced
+    },
     pages() {
       return this.$router.options.routes.filter((page) => {
         return page.meta.listed;
@@ -197,6 +227,13 @@ module.exports = {
         this.user = response.data;
       });
     },
+    getAnnouncementStatus() {
+      this.$api.announcement.announced().then((response) => {
+        console.log(response.data)
+        this.announced = response.data["announced"];
+        this.$api.announcement.announce();
+      });
+    },
     getIdentity() {
       this.$api.identity.get().then((response) => {
         this.identity = JSON.parse(response.data);
@@ -237,6 +274,7 @@ module.exports = {
     this.checkDarkMode();
     this.getIdentity();
     this.getCurrentUser();
+    this.getAnnouncementStatus();
     this.setTimeLocal();
     this.clockInterval = setInterval(() => {
       this.setTimeLocal();
diff --git a/jumpscale/packages/admin/frontend/api.js b/jumpscale/packages/admin/frontend/api.js
index c6d07c8bb8..c25a5bb7f4 100644
--- a/jumpscale/packages/admin/frontend/api.js
+++ b/jumpscale/packages/admin/frontend/api.js
@@ -181,12 +181,12 @@ const apiClient = {
                 url: `${baseURL}/admin/get_developer_options`
             })
         },
-        setDeveloperOptions: (testCert, overProvision, explorerLogs, sortNodesBySRU) => {
+        setDeveloperOptions: (testCert, overProvision, explorerLogs, escalationEmails, autoExtendPools, sortNodesBySRU) => {
             return axios({
                 url: `${baseURL}/admin/set_developer_options`,
                 method: "post",
                 headers: { 'Content-Type': 'application/json' },
-                data: { test_cert: testCert, over_provision: overProvision, explorer_logs: explorerLogs, sort_nodes_by_sru: sortNodesBySRU }
+                data: { test_cert: testCert, over_provision: overProvision, explorer_logs: explorerLogs, sort_nodes_by_sru: sortNodesBySRU, escalation_emails: escalationEmails, auto_extend_pools: autoExtendPools }
             })
         },
         clearBlockedNodes: () => {
@@ -205,6 +205,50 @@ const apiClient = {
             })
         }
     },
+    emailServerConfig: {
+        get: () => {
+            return axios({
+                url: `${baseURL}/admin/get_email_server_config`
+            })
+        },
+        set: (host, port, username, password) => {
+            return axios({
+                url: `${baseURL}/admin/set_email_server_config`,
+                method: "post",
+                headers: { "Content-Type": "application/json" },
+                data: {
+                    host: host,
+                    port: port,
+                    username: username,
+                    password: password
+                }
+            })
+        },
+    },
+    escalationEmails: {
+        list: () => {
+            return axios({
+                url: `${baseURL}/admin/list_escalation_emails`
+            })
+        },
+        add: (email) => {
+            return axios({
+                url: `${baseURL}/admin/add_escalation_email`,
+                method: "post",
+                headers: { 'Content-Type': 'application/json' },
+                data: { email: email }
+            })
+        },
+        delete: (email) => {
+            return axios({
+                url: `${baseURL}/admin/delete_escalation_email`,
+                method: "post",
+                headers: { 'Content-Type': 'application/json' },
+                data: { email: email }
+            })
+        }
+
+    },
     explorers: {
         get: () => {
             return axios({
@@ -534,5 +578,19 @@ const apiClient = {
                 method: "get"
             })
         },
+    },
+    announcement: {
+        announced: () => {
+            return axios({
+                url: `/admin/api/announced`,
+                method: "get"
+            })
+        },
+        announce: () => {
+            return axios({
+                url: `/admin/api/announce`,
+                method: "get"
+            })
+        },
     }
 }
diff --git a/jumpscale/packages/admin/frontend/components/settings/AddEscalationEmail.vue b/jumpscale/packages/admin/frontend/components/settings/AddEscalationEmail.vue
new file mode 100644
index 0000000000..70baf259cf
--- /dev/null
+++ b/jumpscale/packages/admin/frontend/components/settings/AddEscalationEmail.vue
@@ -0,0 +1,67 @@
+<template>
+  <base-dialog
+    title="Add escalation email"
+    v-model="dialog"
+    :error="error"
+    :loading="loading"
+  >
+    <template #default>
+      <v-form>
+        <v-text-field
+          v-model="form.email"
+          label="email"
+          :rules="emailRules"
+          dense
+        ></v-text-field>
+      </v-form>
+    </template>
+    <template #actions>
+      <v-btn text @click="close">Close</v-btn>
+      <v-btn text @click="submit">Add</v-btn>
+    </template>
+  </base-dialog>
+</template>
+
+<script>
+module.exports = {
+  data() {
+    return {
+      emailRules: [
+        (v) => !!v || "E-mail is required",
+        (v) => /.+@.+\..+/.test(v) || "E-mail must be valid",
+      ],
+    };
+  },
+  mixins: [dialog],
+  methods: {
+    is_email_valid() {
+      console.log(this.form.email && /.+@.+\..+/.test(this.form.email));
+      if (this.form.email && /.+@.+\..+/.test(this.form.email)) {
+        return true;
+      } else {
+        return false;
+      }
+    },
+    submit() {
+      this.loading = true;
+      this.error = null;
+      if (!this.is_email_valid()) {
+        console.log("Email is not valid");
+        this.loading = false;
+        return;
+      }
+      this.$api.escalationEmails
+        .add(this.form.email)
+        .then((response) => {
+          this.done("Email is added");
+        })
+        .catch((error) => {
+          this.error = error.response.data.error;
+        })
+        .finally(() => {
+          this.loading = false;
+        });
+    },
+  },
+};
+</script>
diff --git a/jumpscale/packages/admin/frontend/components/settings/EmailServerConfig.vue b/jumpscale/packages/admin/frontend/components/settings/EmailServerConfig.vue
new file mode 100644
index 0000000000..3ff1d9d35a
--- /dev/null
+++ b/jumpscale/packages/admin/frontend/components/settings/EmailServerConfig.vue
@@ -0,0 +1,79 @@
+<template>
+  <base-dialog
+    title="Email Server Configurations"
+    v-model="dialog"
+    :error="error"
+    :loading="loading"
+  >
+    <template #default>
+      <v-form>
+        <v-text-field
+          v-model="emailServerConfig.host"
+          label="SMTP Host"
+          dense
+        ></v-text-field>
+        <v-text-field
+          v-model="emailServerConfig.port"
+          label="Port"
+          dense
+        ></v-text-field>
+        <v-text-field
+          v-model="emailServerConfig.username"
+          label="Username"
+          dense
+        ></v-text-field>
+        <v-text-field
+          v-model="emailServerConfig.password"
+          label="Password"
+          type="password"
+          dense
+        ></v-text-field>
+      </v-form>
+    </template>
+    <template #actions>
+      <v-btn text @click="close">Close</v-btn>
+      <v-btn text @click="submit">Add</v-btn>
+    </template>
+  </base-dialog>
+</template>
+
+<script>
+module.exports = {
+  mixins: [dialog],
+  data() {
+    return {
+      emailServerConfig: {},
+    };
+  },
+  methods: {
+    getEmailServerConfig() {
+      this.$api.emailServerConfig.get().then((response) => {
+        this.emailServerConfig = JSON.parse(response.data).data;
+      });
+    },
+    submit() {
+      this.loading = true;
+      this.error = null;
+      this.$api.emailServerConfig
+        .set(
+          this.emailServerConfig.host,
+          this.emailServerConfig.port,
+          this.emailServerConfig.username,
+          this.emailServerConfig.password
+        )
+        .then((response) => {
+          this.done("Email Server config updated");
+        })
+        .catch((error) => {
+          this.error = error.response.data.error;
+        })
+        .finally(() => {
+          this.loading = false;
+        });
+    },
+  },
+  mounted() {
+    this.getEmailServerConfig();
+  },
+};
+</script>
diff --git a/jumpscale/packages/admin/frontend/components/settings/Settings.vue b/jumpscale/packages/admin/frontend/components/settings/Settings.vue
index 9925df8a46..2229ee165a 100644
--- a/jumpscale/packages/admin/frontend/components/settings/Settings.vue
+++ b/jumpscale/packages/admin/frontend/components/settings/Settings.vue
@@ -6,7 +6,12 @@
       <template #default>
         <v-row align="start" justify="start">
           <v-col class="mt-0 pt-0" cols="12" md="4">
-            <base-section title="Admins" icon="mdi-account-lock" :loading="loading.admins">
+            <!-- List-Admins -->
+            <base-section
+              title="Admins"
+              icon="mdi-account-lock"
+              :loading="loading.admins"
+            >
               <template #actions>
                 <v-btn text @click.stop="dialogs.addAdmin = true">
                   <v-icon left>mdi-plus</v-icon>Add
@@ -24,16 +29,18 @@
                 label
                 close
                 close-icon="mdi-close-circle-outline"
-              >{{ admin }}</v-chip>
+                >{{ admin }}</v-chip
+              >
             </base-section>
+            <!-- List-Escalation-Emails -->
             <base-section
               class="mt-3"
-              title="SSH keys"
-              icon="mdi-key"
-              :loading="loading.sshkeys"
+              title="Escalation Emails"
+              icon="mdi-email"
+              :loading="loading.escalationEmails"
             >
               <template #actions>
-                <v-btn text @click.stop="dialogs.addSshkey = true">
+                <v-btn text @click.stop="dialogs.escalationEmail = true">
                   <v-icon left>mdi-plus</v-icon>Add
                 </v-btn>
               </template>
@@ -41,17 +48,84 @@
               <v-chip
                 class="ma-2"
                 color="primary"
-                v-for="(sshkey, id) in sshkeys"
-                :key="id"
+                min-width="50"
+                v-for="email in escalationEmails"
+                :key="email"
+                @click:close="removeEscalationEmail(email)"
                 outlined
                 label
                 close
                 close-icon="mdi-close-circle-outline"
-                @click="viewSshkey(id, sshkey)"
-                @click:close="deleteSshkey(id)"
-                >{{ id }}</v-chip
+                >{{ email }}</v-chip
               >
             </base-section>
+            <!-- Email Server Config start -->
+            <base-section
+              class="mt-3"
+              title="Email Sever Configurations"
+              icon="mdi-access-point-network"
+              :loading="loading.emailServerConfig"
+            >
+              <template #actions>
+                <v-btn text @click.stop="dialogs.emailServerConfig = true">
+                  <v-icon left>mdi-lead-pencil</v-icon>Edit
+                </v-btn>
+              </template>
+
+              <template>
+                <v-simple-table>
+                  <template v-slot:default>
+                    <v-tooltip bottom>
+                      <template v-slot:activator="{ on, attrs }">
+                        <tbody v-bind="attrs" v-on="on">
+                          <tr>
+                            <td>SMTP Host</td>
+                            <td>{{ emailServerConfig.host }}</td>
+                          </tr>
+                        </tbody>
+                      </template>
+                      <span>SMTP host server</span>
+                    </v-tooltip>
+                    <v-tooltip bottom>
+                      <template v-slot:activator="{ on, attrs }">
+                        <tbody v-bind="attrs" v-on="on">
+                          <tr>
+                            <td>Port</td>
+                            <td>{{ emailServerConfig.port }}</td>
+                          </tr>
+                        </tbody>
+                      </template>
+                      <span>SMTP host server port</span>
+                    </v-tooltip>
+                    <v-tooltip bottom>
+                      <template v-slot:activator="{ on, attrs }">
+                        <tbody v-bind="attrs" v-on="on">
+                          <tr>
+                            <td>Username</td>
+                            <td>{{ emailServerConfig.username }}</td>
+                          </tr>
+                        </tbody>
+                      </template>
+                      <span>Login username</span>
+                    </v-tooltip>
+                    <v-tooltip bottom>
+                      <template v-slot:activator="{ on, attrs }">
+                        <tbody v-bind="attrs" v-on="on">
+                          <tr>
+                            <td>Password</td>
+                            <td class="hidetext">
+                              {{ emailServerConfig.password }}
+                            </td>
+                          </tr>
+                        </tbody>
+                      </template>
+                      <span>Login password</span>
+                    </v-tooltip>
+                  </template>
+                </v-simple-table>
+              </template>
+            </base-section>
+            <!-- end of Email server config-->
           </v-col>
           <v-col class="mt-0 pt-0" cols="12" md="4">
             <base-section
@@ -72,7 +146,8 @@
                 :key="i"
                 :color="getColor(identity.instance_name)"
                 @click="openIdentity(identity.instance_name)"
-              >{{ identity.instance_name }}</v-chip>
+                >{{ identity.instance_name }}</v-chip
+              >
             </base-section>
           </v-col>
           <v-col class="mt-0 pt-0" cols="12" md="3">
@@ -103,6 +178,20 @@
                 :label="`Enable explorer logs`"
                 @click.stop="setDeveloperOptions()"
               ></v-switch>
+              <v-switch
+                hide-details
+                class="my-2 pl-2"
+                v-model="escalationEmailsEnabled"
+                :label="`Enable sending escalation emails`"
+                @click.stop="setDeveloperOptions()"
+              ></v-switch>
+              <v-switch
+                hide-details
+                class="my-2 pl-2"
+                v-model="autoExtendPools"
+                :label="`Pools auto extension`"
+                @click.stop="setDeveloperOptions()"
+              ></v-switch>
               <v-switch
                 hide-details
                 class="my-2 pl-2"
@@ -116,14 +205,16 @@
                 small
                 color="info"
                 @click="showConfig()"
-              >Show 3Bot configurations</v-btn>
+                >Show 3Bot configurations</v-btn
+              >
               <v-btn
                 hide-details
                 class="my-2 ml-2"
                 small
                 color="success"
                 @click="clearBlockedNodes()"
-              >Clear blocked nodes</v-btn>
+                >Clear blocked nodes</v-btn
+              >
             </base-section>
           </v-col>
         </v-row>
@@ -131,12 +222,50 @@
     </base-component>
 
     <add-admin v-model="dialogs.addAdmin" @done="listAdmins"></add-admin>
-    <add-sshkey v-model="dialogs.addSshkey" @done="listSshkeys"></add-sshkey>
-    <remove-admin v-model="dialogs.removeAdmin" :name="selectedAdmin" @done="listAdmins"></remove-admin>
-    <sshkey-info v-if="selectedSshkey" v-model="dialogs.sshkeyInfo" :data="selectedSshkey"></sshkey-info>
-    <identity-info v-model="dialogs.identityInfo" :name="selectedIdentity" @done="listIdentities"></identity-info>
-    <add-identity v-model="dialogs.addIdentity" @done="listIdentities"></add-identity>
-    <config-view v-if="configurations" v-model="dialogs.configurations" :data="configurations"></config-view>
+    <add-escaltion-email
+      v-model="dialogs.escalationEmail"
+      @done="listEscaltionEmails"
+    ></add-escaltion-email>
+
+    <set-email-server-config
+      v-model="dialogs.emailServerConfig"
+      :emailServerConfig="emailServerConfig"
+      @done="getEmailServerConfig"
+    >
+    </set-email-server-config>
+    <remove-admin
+      v-model="dialogs.removeAdmin"
+      :name="selectedAdmin"
+      @done="listAdmins"
+    ></remove-admin>
+    <identity-info
+      v-model="dialogs.identityInfo"
+      :name="selectedIdentity"
+      @done="listIdentities"
+    ></identity-info>
+    <add-identity
+      v-model="dialogs.addIdentity"
+      @done="listIdentities"
+    ></add-identity>
+    <remove-admin
+      v-model="dialogs.removeAdmin"
+      :name="selectedAdmin"
+      @done="listAdmins"
+    ></remove-admin>
+    <identity-info
+      v-model="dialogs.identityInfo"
+      :name="selectedIdentity"
+      @done="listIdentities"
+    ></identity-info>
+    <add-identity
+      v-model="dialogs.addIdentity"
+      @done="listIdentities"
+    ></add-identity>
+    <config-view
+      v-if="configurations"
+      v-model="dialogs.configurations"
+      :data="configurations"
+    ></config-view>
   </div>
 </template>
 
@@ -144,9 +273,9 @@
 module.exports = {
   components: {
     "add-admin": httpVueLoader("./AddAdmin.vue"),
-    "add-sshkey": httpVueLoader("./AddSshkey.vue"),
+    "add-escaltion-email": httpVueLoader("./AddEscalationEmail.vue"),
+    "set-email-server-config": httpVueLoader("./EmailServerConfig.vue"),
     "remove-admin": httpVueLoader("./RemoveAdmin.vue"),
-    "sshkey-info": httpVueLoader("./SshkeyInfo.vue"),
     "identity-info": httpVueLoader("./IdentityInfo.vue"),
     "add-identity": httpVueLoader("./AddIdentity.vue"),
     "config-view": httpVueLoader("./ConfigurationsInfo.vue"),
@@ -155,23 +284,24 @@ module.exports = {
     return {
       loading: {
         admins: false,
-        sshkeys: false,
         identities: false,
         developerOptions: false,
+        escalationEmails: false,
+        emailServerConfig: false,
       },
       selectedAdmin: null,
       dialogs: {
         addAdmin: false,
-        addSshkey: false,
         removeAdmin: false,
-        sshkeyInfo: false,
         identityInfo: false,
         addIdentity: false,
+        escalationEmail: false,
+        emailServerConfig: false,
         configurations: false,
       },
       admins: [],
-      sshkeys: [],
-      selectedSshkey: null,
+      escalationEmails: [],
+      emailServerConfig: {},
       identity: null,
       selectedIdentity: null,
       identities: [],
@@ -179,6 +309,8 @@ module.exports = {
       testCert: false,
       overProvision: false,
       explorerLogs: false,
+      escalationEmailsEnabled: false,
+      autoExtendPools: false,
       sortNodesBySru: false,
     };
   },
@@ -194,39 +326,48 @@ module.exports = {
           this.loading.admins = false;
         });
     },
-    removeAdmin(name) {
-      this.selectedAdmin = name;
-      this.dialogs.removeAdmin = true;
+    listEscaltionEmails() {
+      this.loading.escalationEmails = true;
+      this.$api.escalationEmails
+        .list()
+        .then((response) => {
+          this.escalationEmails = JSON.parse(response.data).data;
+        })
+        .finally(() => {
+          this.loading.escalationEmails = false;
+        });
     },
-    listSshkeys() {
-      this.loading.sshkeys = true;
-      this.$api.sshkeys
-      .list()
-      .then((response) => {
-        this.sshkeys = JSON.parse(response.data).data;
-      })
-      .finally(() => {
-        this.loading.sshkeys = false;
+    getEmailServerConfig() {
+      this.$api.emailServerConfig.get().then((response) => {
+        this.emailServerConfig = JSON.parse(response.data).data;
       });
     },
-    viewSshkey (id, sshkey) {
-      this.selectedSshkey = {id: id, sshkey: sshkey};
-      this.dialogs.sshkeyInfo = true;
+    setEmailServerConfig(hostname, port, username, password) {
+      this.loading.emailServerConfig = true;
+      this.$api.emailServerConfig
+        .set(host, port, username, password)
+        .then((response) => {
+          this.emailServerConfig = JSON.parse(response.data).data;
+        })
+        .finally(() => {
+          this.loading.emailServerConfig = false;
+        });
+    },
+    removeEscalationEmail(email) {
+      console.log("this email should be removed", email);
+      this.loading.escalationEmails = true;
+      this.$api.escalationEmails
+        .delete(email)
+        .then((response) => {
+          this.escalationEmails = JSON.parse(response.data).data;
+        })
+        .finally(() => {
+          this.loading.escalationEmails = false;
+        });
     },
-    deleteSshkey(id) {
-      this.loading.sshkeys = true;
-      this.$api.sshkeys
-      .delete(id)
-      .then((response) => {
-        this.alert("SSH key removed", "success");
-        this.sshkeys = JSON.parse(response.data).data;
-      })
-      .catch(() => {
-        this.alert("Failed to remove SSH key", "error");
-      })
-      .finally(() => {
-        this.loading.sshkeys = false;
-      });
+    removeAdmin(name) {
+      this.selectedAdmin = name;
+      this.dialogs.removeAdmin = true;
     },
     listIdentities() {
       this.getCurrentIdentity();
@@ -293,6 +434,8 @@ module.exports = {
           this.testCert = developerOptions["test_cert"];
           this.overProvision = developerOptions["over_provision"];
           this.explorerLogs = developerOptions["explorer_logs"];
+          this.escalationEmailsEnabled = developerOptions["escalation_emails"];
+          this.autoExtendPools = developerOptions["auto_extend_pools"];
           this.sortNodesBySru = developerOptions["sort_nodes_by_sru"];
         })
         .finally(() => {
@@ -305,13 +448,15 @@ module.exports = {
           this.testCert,
           this.overProvision,
           this.explorerLogs,
+          this.escalationEmailsEnabled,
+          this.autoExtendPools,
           this.sortNodesBySru
         )
         .then((response) => {
           this.alert("Developer options updated", "success");
         })
         .catch((error) => {
-          this.alert("Failed to update developer options", "error");
+          this.alert("Failed to update developer options, " + error, "error");
         });
     },
     clearBlockedNodes() {
@@ -327,10 +472,11 @@ module.exports = {
   },
   mounted() {
     this.listAdmins();
-    this.listSshkeys();
+    this.getEmailServerConfig();
     this.getCurrentIdentity();
     this.listIdentities();
     this.getDeveloperOptions();
+    this.listEscaltionEmails();
   },
 };
 </script>
diff --git a/jumpscale/packages/admin/frontend/style.css b/jumpscale/packages/admin/frontend/style.css
index f3f2ca1138..0ee47e9e50 100644
--- a/jumpscale/packages/admin/frontend/style.css
+++ b/jumpscale/packages/admin/frontend/style.css
@@ -66,3 +66,8 @@ a {
 ::-webkit-scrollbar-thumb:hover {
   background: #555;
 }
+
+.hidetext {
+  -webkit-text-security: disc;
+  /* Default */
+}
\ No newline at end of file
diff --git a/jumpscale/packages/backup/actors/threebot_deployer.py b/jumpscale/packages/backup/actors/threebot_deployer.py
index e2bd241b01..8ec4aac75a 100644
--- a/jumpscale/packages/backup/actors/threebot_deployer.py
+++ b/jumpscale/packages/backup/actors/threebot_deployer.py
@@ -22,6 +22,13 @@ def downloaded_packages_path(self):
             j.sals.fs.mkdirs(packages_path)
         return packages_path
 
+    @property
+    def ssh_dir_path(self):
+        ssh_path = j.sals.fs.join_paths(j.core.dirs.HOMEDIR, ".ssh")
+        if not j.sals.fs.exists(ssh_path):
+            j.sals.fs.mkdir(ssh_path)
+        return ssh_path
+
     @property
     def user_code_path(self):
         code_path = j.sals.fs.join_paths(j.core.dirs.CODEDIR, "playground")
@@ -79,6 +86,7 @@ def backup(self, tags=None) -> str:
             repo.backup(j.core.dirs.JSCFGDIR, tags=tags)
             repo.backup(self.downloaded_packages_path, tags=tags)
             repo.backup(self.user_code_path, tags=tags)
+            repo.backup(self.ssh_dir_path, tags=tags)
         return j.data.serializers.json.dumps({"data": "backup done"})
 
     @actor_method
diff --git a/jumpscale/packages/tfgrid_solutions/chats/exposed.py b/jumpscale/packages/tfgrid_solutions/chats/exposed.py
index a064e8d6c5..ae7d6df663 100644
--- a/jumpscale/packages/tfgrid_solutions/chats/exposed.py
+++ b/jumpscale/packages/tfgrid_solutions/chats/exposed.py
@@ -253,7 +253,7 @@ def reservation(self):
                 solution_uuid=self.solution_id,
             )
         else:
-            self.tcprouter_id = deployer.expose_address(
+            self.tcprouter_id, _ = deployer.expose_address(
                 pool_id=self.pool_id,
                 gateway_id=self.domain_gateway.node_id,
                 network_name=self.network_name,
diff --git a/jumpscale/packages/tfgrid_solutions/chats/gollum.py b/jumpscale/packages/tfgrid_solutions/chats/gollum.py
index b46165485f..1d89284cec 100644
--- a/jumpscale/packages/tfgrid_solutions/chats/gollum.py
+++ b/jumpscale/packages/tfgrid_solutions/chats/gollum.py
@@ -181,23 +181,22 @@ def reservation(self):
             )
 
         # expose container domain
-        self.workload_ids.append(
-            deployer.expose_address(
-                pool_id=self.pool_id,
-                gateway_id=self.gateway.node_id,
-                network_name=self.network_view.name,
-                local_ip=self.ip_address,
-                port=80,
-                tls_port=443,
-                trc_secret=self.secret,
-                node_id=self.selected_node.node_id,
-                reserve_proxy=True,
-                domain_name=self.domain,
-                proxy_pool_id=self.gateway_pool.pool_id,
-                solution_uuid=self.solution_id,
-                **self.solution_metadata,
-            )
+        wid, _ = deployer.expose_address(
+            pool_id=self.pool_id,
+            gateway_id=self.gateway.node_id,
+            network_name=self.network_view.name,
+            local_ip=self.ip_address,
+            port=80,
+            tls_port=443,
+            trc_secret=self.secret,
+            node_id=self.selected_node.node_id,
+            reserve_proxy=True,
+            domain_name=self.domain,
+            proxy_pool_id=self.gateway_pool.pool_id,
+            solution_uuid=self.solution_id,
+            **self.solution_metadata,
         )
+        self.workload_ids.append(wid)
         success = deployer.wait_workload(self.workload_ids[1], self)
         if not success:
             solutions.cancel_solution(self.workload_ids)
diff --git a/jumpscale/packages/tfgrid_solutions/scripts/threebot/entrypoint.py b/jumpscale/packages/tfgrid_solutions/scripts/threebot/entrypoint.py
index 060b30e412..6c6a9df526 100644
--- a/jumpscale/packages/tfgrid_solutions/scripts/threebot/entrypoint.py
+++ b/jumpscale/packages/tfgrid_solutions/scripts/threebot/entrypoint.py
@@ -10,7 +10,6 @@
 
 def main():
     BACKUP_ACTOR = Backup()
-
     instance_name = os.environ.get("INSTANCE_NAME")
     threebot_name = os.environ.get("THREEBOT_NAME")
     domain = os.environ.get("DOMAIN")
@@ -28,10 +27,6 @@ def main():
 
     new = True
 
-    resp = requests.get("https://explorer.grid.tf/api/v1/users", params={"name": tname})
-    if resp.json():
-        new = False
-
     j.logger.info("Generating guest identity ...")
     identity_main = j.core.identity.get(
         "main", tname=tname, email=email, words=words, explorer_url="https://explorer.grid.tf/api/v1"
@@ -46,16 +41,10 @@ def main():
         identity.register()
         identity.save()
 
-    j.core.identity.set_default("main")
+    default_identity = os.environ.get("DEFAULT_IDENTITY", "main")
+    j.core.identity.set_default(default_identity)
 
     if backup_password:
-        # Seprate the logic of wallet creation in case of stellar failure it still takes the backup
-        # Create a funded wallet to the threebot testnet
-        try:
-            j.clients.stellar.create_testnet_funded_wallet(f"{threebot_name}_{instance_name}")
-        except Exception as e:
-            j.logger.error(str(e))
-
         # Sanitation for the case user deleted his old backups!
         try:
             BACKUP_ACTOR.init(backup_password, new=False)
diff --git a/jumpscale/packages/tfgrid_solutions/services/auto_extend_pools.py b/jumpscale/packages/tfgrid_solutions/services/auto_extend_pools.py
new file mode 100644
index 0000000000..80375f4e3c
--- /dev/null
+++ b/jumpscale/packages/tfgrid_solutions/services/auto_extend_pools.py
@@ -0,0 +1,18 @@
+from jumpscale.tools.servicemanager.servicemanager import BackgroundService
+from jumpscale.packages.tfgrid_solutions.utils import auto_extend_pools
+from jumpscale.loader import j
+
+
+class AutoExtendPoolService(BackgroundService):
+    def __init__(self, name="threebot_deployer_auto_extend_pools", interval=60 * 60 * 24, *args, **kwargs):
+        """
+        Test service that runs every 1 day
+        """
+        super().__init__(name, interval, *args, **kwargs)
+
+    def job(self):
+        auto_extend_pools()
+        j.logger.info("Auto extend pool service done successfully")
+
+
+service = AutoExtendPoolService()
diff --git a/jumpscale/packages/tfgrid_solutions/utils.py b/jumpscale/packages/tfgrid_solutions/utils.py
new file mode 100644
index 0000000000..3aa8064ea0
--- /dev/null
+++ b/jumpscale/packages/tfgrid_solutions/utils.py
@@ -0,0 +1,92 @@
+import time
+from decimal import Decimal
+from jumpscale.loader import j
+
+
+def get_payment_amount(pool):
+    escrow_info = pool.escrow_information
+    resv_id = pool.reservation_id
+    escrow_address = escrow_info.address
+    escrow_asset = escrow_info.asset
+    total_amount = escrow_info.amount
+    if not total_amount:
+        return
+    total_amount_dec = Decimal(total_amount) / Decimal(1e7)
+    total_amount = "{0:f}".format(total_amount_dec)
+    return resv_id, escrow_address, escrow_asset, total_amount
+
+
+def pay_pool(pool_info):
+    # Get the amount of payment
+    resv_id, escrow_address, escrow_asset, total_amount = get_payment_amount(pool_info)
+    # Get the user wallets
+    wallets = j.sals.reservation_chatflow.reservation_chatflow.list_wallets()
+    for wallet_name, wallet_val in wallets.items():
+        j.logger.info(f"Trying to pay pool {pool_info.pool_id} with wallet {wallet_name}")
+        try:
+            wallet_val.transfer(
+                destination_address=escrow_address, amount=total_amount, asset=escrow_asset, memo_text=f"p-{resv_id}"
+            )
+            return True
+        except:
+            j.logger.warning(f"failed to pay pool {pool_info.pool_id} with wallet {wallet_name}")
+    return False
+
+
+def check_pool_expiration(pool, threshold_days=14):
+    remaining_days = (pool.empty_at - time.time()) / 86400  # converting seconds to days
+    return remaining_days < threshold_days and remaining_days > 0
+
+
+def calculate_pool_units(pool, days=14):
+    cu = pool.active_cu * 60 * 60 * 24 * days
+    su = pool.active_su * 60 * 60 * 24 * days
+    return cu, su
+
+
+def auto_extend_pools():
+    pools = j.sals.zos.get().pools.list()
+    for pool in pools:
+        if check_pool_expiration(pool):
+            cu, su = calculate_pool_units(pool)
+            auto_extend_pool(pool.pool_id, int(cu), int(su))
+
+
+def auto_extend_pool(pool_id, cu, su, currencies=None):
+    currencies = currencies or ["TFT"]
+    try:
+        pool_info = j.sals.zos.get().pools.extend(pool_id, cu, su, currencies=currencies)
+    except Exception as e:
+        send_pool_info_mail(pool_id)
+        j.logger.error(f"Error happend during extending the pool, {str(e)}")
+    if not pay_pool(pool_info):
+        send_pool_info_mail(pool_id)
+
+
+def send_pool_info_mail(pool_id, sender="support@threefold.com"):
+    recipients_emails = []
+    user_mail = j.core.identity.me.email
+    recipients_emails.append(user_mail)
+    escalation_emails = j.core.config.get("ESCALATION_EMAILS", [])
+    recipients_emails.extend(escalation_emails)
+    message = (
+        f"The pool with Id {pool_id} is about to expire and we are not "
+        "able to extend it automatically, "
+        "please check the fund in your wallets and extend it manually "
+        "or contact our support team"
+    )
+    send_mail(recipients_emails, message, sender=sender)
+
+
+def send_mail(recipients_emails=None, message="", sender=""):
+    """
+    This method send mail in case the auto extend fail
+    """
+    recipients_emails = recipients_emails or []
+    mail = j.clients.mail.get("mail")
+    mail_config = j.core.config.get("EMAIL_SERVER_CONFIG")
+    mail.smtp_server = mail_config.get("host")
+    mail.smtp_port = mail_config.get("port")
+    mail.login = mail_config.get("username")
+    mail.password = mail_config.get("password")
+    mail.send(recipients_emails, sender=sender, message=message)
diff --git a/jumpscale/packages/threebot_deployer/actors/backup.py b/jumpscale/packages/threebot_deployer/actors/backup.py
index 721dacfaa2..3929f7429b 100644
--- a/jumpscale/packages/threebot_deployer/actors/backup.py
+++ b/jumpscale/packages/threebot_deployer/actors/backup.py
@@ -8,7 +8,7 @@
 from nacl.public import Box
 
 from jumpscale.loader import j
-from jumpscale.packages.threebot_deployer.models.backup_tokens_sal import BACKUP_MODEL_FACTORY
+from jumpscale.packages.threebot_deployer.models import BACKUP_MODEL_FACTORY
 from jumpscale.servers.gedis.baseactor import BaseActor, actor_method
 
 BACKUP_SERVER1 = "backup_server1"
@@ -57,10 +57,10 @@ def init(self, threebot_name: str, passwd: str, new=True, token: str = "") -> li
         else:
             try:
                 self.ssh_server1.sshclient.run(
-                    f"cd ~/backup; htpasswd -vb  .htpasswd {threebot_name} {password_backup}"
+                    f"cd /root/backup; htpasswd -vb  .htpasswd {threebot_name} {password_backup}"
                 )
                 self.ssh_server2.sshclient.run(
-                    f"cd ~/backup; htpasswd -vb  .htpasswd {threebot_name} {password_backup}"
+                    f"cd /root/backup; htpasswd -vb  .htpasswd {threebot_name} {password_backup}"
                 )
             except:
                 raise j.exceptions.Value(f"3Bot name or password is incorrect")
diff --git a/jumpscale/packages/threebot_deployer/bottle/solutions.py b/jumpscale/packages/threebot_deployer/bottle/solutions.py
index 0500a06373..df0d21ae9f 100644
--- a/jumpscale/packages/threebot_deployer/bottle/solutions.py
+++ b/jumpscale/packages/threebot_deployer/bottle/solutions.py
@@ -1,5 +1,10 @@
 from beaker.middleware import SessionMiddleware
 from bottle import Bottle, request, HTTPResponse
+from jumpscale.packages.threebot_deployer.bottle.utils import (
+    list_threebot_solutions,
+    stop_threebot_solution,
+    delete_threebot_solution,
+)
 
 from jumpscale.loader import j
 from jumpscale.packages.auth.bottle.auth import SESSION_OPTS, login_required, get_user_info
@@ -12,19 +17,39 @@
 @app.route("/api/threebots/list")
 @login_required
 def list_threebots() -> str:
-    solutions = []
     user_info = j.data.serializers.json.loads(get_user_info())
-    solutions = j.sals.marketplace.solutions.list_solutions(user_info["username"], "threebot")
-    return j.data.serializers.json.dumps({"data": solutions})
+    threebots = list_threebot_solutions(user_info["username"])
+    return j.data.serializers.json.dumps({"data": threebots})
 
 
-@app.route("/api/solutions/cancel", method="POST")
+@app.route("/api/threebots/stop", method="POST")
 @login_required
-def cancel_solution():
+def stop_threebot() -> str:
+    data = j.data.serializers.json.loads(request.body.read())
     user_info = j.data.serializers.json.loads(get_user_info())
+    if "password" not in data or "uuid" not in data:
+        return HTTPResponse(
+            j.data.serializers.json.dumps({"error": f"invalid body. missing keys"}),
+            status=400,
+            headers={"Content-Type": "application/json"},
+        )
+    stop_threebot_solution(owner=user_info["username"], solution_uuid=data["uuid"], password=data["password"])
+    return j.data.serializers.json.dumps({"data": True})
+
+
+@app.route("/api/threebots/destroy", method="POST")
+@login_required
+def destroy_threebot() -> str:
     data = j.data.serializers.json.loads(request.body.read())
-    j.sals.marketplace.solutions.cancel_solution(user_info["username"], data["wids"], delete_pool=True)
-    return j.data.serializers.json.dumps({"result": True})
+    user_info = j.data.serializers.json.loads(get_user_info())
+    if "password" not in data or "uuid" not in data:
+        return HTTPResponse(
+            j.data.serializers.json.dumps({"error": f"invalid body. missing keys"}),
+            status=400,
+            headers={"Content-Type": "application/json"},
+        )
+    delete_threebot_solution(owner=user_info["username"], solution_uuid=data["uuid"], password=data["password"])
+    return j.data.serializers.json.dumps({"data": True})
 
 
 @app.route("/api/allowed", method="GET")
diff --git a/jumpscale/packages/threebot_deployer/bottle/utils.py b/jumpscale/packages/threebot_deployer/bottle/utils.py
new file mode 100644
index 0000000000..326fea4331
--- /dev/null
+++ b/jumpscale/packages/threebot_deployer/bottle/utils.py
@@ -0,0 +1,424 @@
+from jumpscale.sals.chatflows.chatflows import StopChatFlow
+import uuid
+from jumpscale.sals.marketplace import solutions
+from jumpscale.sals.reservation_chatflow.deployer import deployment_context, DeploymentFailed
+from jumpscale.packages.threebot_deployer.models import USER_THREEBOT_FACTORY, BACKUP_MODEL_FACTORY
+from jumpscale.packages.threebot_deployer.models.user_solutions import ThreebotState
+from jumpscale.clients.explorer.models import WorkloadType, NextAction
+from jumpscale.sals.marketplace import deployer
+from jumpscale.data.serializers import json
+from jumpscale.data import text
+from jumpscale.loader import j
+from jumpscale.data.nacl.jsnacl import NACL
+from contextlib import ContextDecorator
+
+
+THREEBOT_WORKLOAD_TYPES = [WorkloadType.Container, WorkloadType.Subdomain, WorkloadType.Reverse_proxy]
+
+
+class threebot_identity_context(ContextDecorator):
+    def __init__(self, identity_name):
+        self.identity_name = identity_name
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        j.core.identity.delete(self.identity_name)
+
+
+def build_solution_info(workloads, threebot):
+    """used to build to dict containing Threebot information
+    Args:
+        workloads: list of workloads that makeup the threebot solution (subdomain, threebot container, trc container, reverse_proxy)
+    """
+    solution_info = {"wids": [], "name": threebot.name}
+    for workload in workloads:
+        solution_info["wids"].append(workload.id)
+        if workload.info.workload_type in [WorkloadType.Reverse_proxy, WorkloadType.Subdomain]:
+            solution_info["domain"] = workload.domain
+            solution_info["gateway_pool"] = workload.info.pool_id
+            solution_info["gateway"] = workload.info.node_id
+        elif workload.info.workload_type == WorkloadType.Container:
+            workload_result = json.loads(workload.info.result.data_json)
+            if "trc" in workload.flist:
+                continue
+            solution_info.update(
+                {
+                    "ipv4": workload_result["ipv4"],
+                    "ipv6": workload_result["ipv6"],
+                    "flist": workload.flist,
+                    "disk_size": workload.capacity.disk_size,
+                    "cpu": workload.capacity.cpu,
+                    "memory": workload.capacity.memory,
+                    "node": workload.info.node_id,
+                    "compute_pool": workload.info.pool_id,
+                    "network": workload.network_connection[0].network_id,
+                    "branch": workload.environment.get("SDK_VERSION"),
+                    "public_key": workload.environment.get("SSHKEY"),
+                }
+            )
+
+    return solution_info
+
+
+def group_threebot_workloads_by_uuid(threebot, zos):
+    solutions = {threebot.solution_uuid: []}
+    threebot_wids = [
+        threebot.threebot_container_wid,
+        threebot.trc_container_wid,
+        threebot.subdomain_wid,
+        threebot.reverse_proxy_wid,
+    ]
+    for workload in zos.workloads.list(threebot.identity_tid):
+        if workload.id in threebot_wids:
+            solutions[threebot.solution_uuid].append(workload)
+    return solutions
+
+
+def get_threebot_zos(threebot):
+    _, _, listing_identities = j.core.identity.find_many(explorer_url=threebot.explorer_url)
+    listing_identity = list(listing_identities)[0]
+    zos = j.sals.zos.get(listing_identity.instance_name)
+    return zos
+
+
+def list_threebot_solutions(owner):
+    result = []
+    owner = text.removesuffix(owner, ".3bot")
+    cursor, _, threebots = USER_THREEBOT_FACTORY.find_many(owner_tname=owner)
+    threebots = list(threebots)
+    while cursor:
+        cursor, _, result = USER_THREEBOT_FACTORY.find_many(cursor, owner_tname=owner)
+        threebots += list(result)
+    for threebot in threebots:
+        zos = get_threebot_zos(threebot)
+        grouped_identity_workloads = group_threebot_workloads_by_uuid(threebot, zos)
+        workloads = grouped_identity_workloads.get(threebot.solution_uuid)
+        if not workloads:
+            continue
+        solution_info = build_solution_info(workloads, threebot)
+        if "ipv4" not in solution_info or "domain" not in solution_info:
+            continue
+        solution_info["solution_uuid"] = threebot.solution_uuid
+        solution_info["farm"] = threebot.farm_name
+        solution_info["state"] = threebot.state.value
+        solution_info["continent"] = threebot.continent
+        compute_pool = zos.pools.get(solution_info["compute_pool"])
+        solution_info["expiration"] = compute_pool.empty_at
+        if not compute_pool:
+            continue
+        if threebot.state == ThreebotState.RUNNING and compute_pool.empty_at == 9223372036854775807:
+            solution_info["state"] = ThreebotState.STOPPED.value
+            threebot.state = ThreebotState.STOPPED
+            threebot.save()
+        result.append(solution_info)
+    return result
+
+
+def get_threebot_workloads_by_uuid(solution_uuid, identity_name):
+    result = []
+    workloads = solutions.get_workloads_by_uuid(solution_uuid, identity_name=identity_name)
+    for workload in workloads:
+        decrypted_metadata = deployer.decrypt_metadata(workload.info.metadata, identity_name)
+        metadata = json.loads(decrypted_metadata)
+        if metadata.get("form_info", {}).get("chatflow") != "threebot":
+            continue
+        result.append(workload)
+    return result
+
+
+def get_threebot_config_instance(owner, solution_uuid):
+    owner = text.removesuffix(owner, ".3bot")
+    threebot = USER_THREEBOT_FACTORY.find(f"threebot_{solution_uuid}")
+    if not threebot:
+        raise j.exceptions.NotFound(f"Threebot with uuid {solution_uuid} does not exist")
+    if threebot.owner_tname != owner:
+        raise j.exceptions.Permission(f"user {owner} does not own threebot with uuid {solution_uuid}")
+    return threebot
+
+
+def generate_user_identity(threebot, password, zos):
+    identity_tid = threebot.identity_tid
+    user = zos._explorer.users.get(identity_tid)
+    words = j.data.encryption.key_to_mnemonic(password.encode().zfill(32))
+    seed = j.data.encryption.mnemonic_to_key(words)
+    pubkey = NACL(seed).get_verify_key_hex()
+    if pubkey != user.pubkey:
+        raise j.exceptions.Permission("Invalid Password")
+    suffix = "main"
+    if "testnet" in threebot.explorer_url:
+        suffix = "test"
+    identity_name = f"{user.name}_{suffix}"
+    identity = j.core.identity.get(
+        identity_name, tname=user.name, email=user.email, words=words, explorer_url=threebot.explorer_url
+    )
+    identity.register()
+    identity.save()
+    return identity
+
+
+def stop_threebot_solution(owner, solution_uuid, password):
+    owner = text.removesuffix(owner, ".3bot")
+    threebot = get_threebot_config_instance(owner, solution_uuid)
+    zos = get_threebot_zos(threebot)
+    identity = generate_user_identity(threebot, password, zos)
+    zos = j.sals.zos.get(identity.instance_name)
+    with threebot_identity_context(identity.instance_name):
+        solution_workloads = get_threebot_workloads_by_uuid(solution_uuid, identity.instance_name)
+        for workload in solution_workloads:
+            if workload.info.next_action == NextAction.DEPLOY:
+                zos.workloads.decomission(workload.id)
+        threebot.state = ThreebotState.STOPPED
+        threebot.save()
+    return threebot
+
+
+def delete_threebot_solution(owner, solution_uuid, password):
+    threebot = stop_threebot_solution(owner, solution_uuid, password)
+    threebot_name = threebot.name
+    ssh_server1 = j.clients.sshclient.get("backup_server1")
+    ssh_server2 = j.clients.sshclient.get("backup_server2")
+    try:
+        ssh_server1.sshclient.run(
+            f"cd ~/backup; htpasswd -D  .htpasswd {threebot_name}; cd /home/backup_config; rm -r {threebot_name}"
+        )
+        ssh_server2.sshclient.run(
+            f"cd ~/backup; htpasswd -D  .htpasswd {threebot_name}; cd /home/backup_config; rm -r {threebot_name}"
+        )
+    except:
+        j.logger.warning(f"Couldn't find backup for uuid {solution_uuid} and owner {owner}")
+    threebot.state = ThreebotState.DELETED
+    threebot.save()
+    return threebot
+
+
+def redeploy_threebot_solution(
+    owner,
+    solution_uuid,
+    backup_password,
+    compute_pool_id=None,
+    gateway_pool_id=None,
+    solution_info=None,
+    node_id=None,
+    bot=None,
+):
+    """
+    Args:
+        owner (str): threebot_name of the logged in user
+        solution_uuid (str): of the not-running threebot that needs to be started
+        compute_pool_id (str): to override the pool id used for container deployment. if not specified, it will use the old pool id
+        gateway_pool_id (str): to override the pool id used for subdomain and proxy deployment. if not specified, it will use the old pool id. (should override the subdomain specified in solution_info)
+        solution_info (dict): to override the information used in deployment. if any key is not specified, it will use the old value
+    """
+    solution_info = solution_info or {}
+    owner = text.removesuffix(owner, ".3bot")
+    j.logger.debug(f"Fetching solution info for uuid {solution_uuid} and owner {owner}")
+    threebot = get_threebot_config_instance(owner, solution_uuid)
+    zos = get_threebot_zos(threebot)
+    identity = generate_user_identity(threebot, backup_password, zos)
+    with threebot_identity_context(identity.instance_name):
+        j.logger.debug(f"Using identity {identity.instance_name}")
+        with deployment_context():
+            zos = j.sals.zos.get(identity.instance_name)
+            solution_workloads = get_threebot_workloads_by_uuid(solution_uuid, identity.instance_name)
+            new_solution_info = build_solution_info(solution_workloads, threebot)
+            j.logger.debug(f"old solution info: {new_solution_info}")
+            new_solution_info.update(solution_info)
+            j.logger.debug(f"updated solution info: {new_solution_info}")
+            gateway_pool_id = gateway_pool_id or new_solution_info["gateway_pool"]
+            compute_pool_id = compute_pool_id or new_solution_info["compute_pool"]
+            # deploy using the new information with a new uuid. a new uuid to not conflict with the old one when listing
+            solution_name = new_solution_info["name"]
+            backup_model = BACKUP_MODEL_FACTORY.get(f"{solution_name}_{owner}")
+            new_solution_uuid = uuid.uuid4().hex
+            metadata = {"form_info": {"Solution name": solution_name, "chatflow": "threebot"}, "owner": f"{owner}.3bot"}
+
+            # select node and update network
+            j.logger.debug(f"fetching network {new_solution_info['network']}")
+            network_view = deployer.get_network_view(new_solution_info["network"], identity_name=identity.instance_name)
+            j.logger.debug(f"searching for available node within pool {compute_pool_id}")
+            if node_id:
+                selected_node = zos._explorer.nodes.get(node_id)
+            else:
+                selected_node = deployer.schedule_container(
+                    pool_id=compute_pool_id,
+                    cru=new_solution_info["cpu"] + 1,
+                    mru=(new_solution_info["memory"] / 1024) + 1,
+                    sru=(new_solution_info["disk_size"] / 1024) + 0.25,
+                    ip_version="IPv6",
+                )
+            j.logger.debug(f"found node with enough capacity {selected_node.node_id}")
+            j.logger.debug(f"adding node {selected_node.node_id} to network {network_view.name}")
+            result = deployer.add_network_node(
+                network_view.name,
+                selected_node,
+                compute_pool_id,
+                network_view,
+                bot=bot,
+                identity_name=identity.instance_name,
+            )
+            if result:
+                for wid in result["ids"]:
+                    success = deployer.wait_workload(
+                        wid, bot, breaking_node_id=selected_node.node_id, identity_name=identity.instance_name
+                    )
+                    if not success:
+                        raise DeploymentFailed(f"Failed to add node {selected_node.node_id} to network {wid}", wid=wid)
+                j.logger.debug(f"node {selected_node.node_id} added to network {network_view.name} successfuly")
+
+            j.logger.debug("searching for a free ip address")
+            network_view = network_view.copy()
+            ip_address = network_view.get_free_ip(selected_node)
+            j.logger.debug(f"found a free ip address {ip_address}")
+
+            workload_ids = []
+            j.logger.debug(f"fetching gateway {new_solution_info['gateway']}")
+            gateway = zos._explorer.gateway.get(new_solution_info["gateway"])
+            addresses = []
+            j.logger.debug(f"resolving gateway {gateway.node_id} name servers")
+            for ns in gateway.dns_nameserver:
+                try:
+                    addresses.append(j.sals.nettools.get_host_by_name(ns))
+                except:
+                    j.logger.error(f"failed to resolve name server {ns} of gateway {gateway.node_id}")
+            if not addresses:
+                raise StopChatFlow(f"the gateway specfied {gateway.node_id} doesn't have any valid name servers")
+
+            domain = new_solution_info["domain"]
+            j.logger.debug(f"deploying domain {domain} pointing to addresses {addresses}")
+            workload_ids.append(
+                deployer.create_subdomain(
+                    pool_id=gateway_pool_id,
+                    gateway_id=gateway.node_id,
+                    subdomain=domain,
+                    addresses=addresses,
+                    solution_uuid=new_solution_uuid,
+                    identity_name=identity.instance_name,
+                    **metadata,
+                )
+            )
+            j.logger.debug(f"waiting for domain workload {workload_ids[-1]} to deploy")
+            success = deployer.wait_workload(workload_ids[-1], identity_name=identity.instance_name)
+            if not success:
+                raise DeploymentFailed(
+                    f"Failed to create subdomain {domain} on gateway {gateway.node_id} {workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.",
+                    wid=workload_ids[-1],
+                    identity_name=identity.instance_name,
+                )
+
+            test_cert = j.config.get("TEST_CERT")
+            j.logger.debug("creating backup token")
+            backup_token = str(j.data.idgenerator.idgenerator.uuid.uuid4())
+            backup_model.token = backup_token
+            backup_model.tname = metadata["owner"]
+            backup_model.save()
+            j.logger.debug(f"backup token {backup_token} created for tname {backup_model.tname}")
+
+            environment_vars = {
+                "SDK_VERSION": new_solution_info["branch"],
+                "INSTANCE_NAME": new_solution_info["name"],
+                "THREEBOT_NAME": owner,
+                "DOMAIN": domain,
+                "SSHKEY": new_solution_info["public_key"],
+                "TEST_CERT": "true" if test_cert else "false",
+                "MARKETPLACE_URL": f"https://{j.sals.nginx.main.websites.threebot_deployer_threebot_deployer_root_proxy_443.domain}/",
+                "DEFAULT_IDENTITY": "test" if "test" in j.core.identity.me.explorer_url else "main",
+            }
+            j.logger.debug(f"deploying threebot container with environment {environment_vars}")
+
+            log_config = j.core.config.get("LOGGING_SINK", {})
+            if log_config:
+                log_config["channel_name"] = new_solution_info["name"]
+
+            workload_ids.append(
+                deployer.deploy_container(
+                    pool_id=compute_pool_id,
+                    node_id=selected_node.node_id,
+                    network_name=network_view.name,
+                    ip_address=ip_address,
+                    flist=new_solution_info["flist"],
+                    env=environment_vars,
+                    cpu=new_solution_info["cpu"],
+                    memory=new_solution_info["memory"],
+                    disk_size=new_solution_info["disk_size"],
+                    secret_env={"BACKUP_PASSWORD": backup_password, "BACKUP_TOKEN": backup_token},
+                    interactive=False,
+                    log_config=log_config,
+                    solution_uuid=new_solution_uuid,
+                    identity_name=identity.instance_name,
+                    **metadata,
+                )
+            )
+            j.logger.debug(f"wating for threebot container workload {workload_ids[-1]} to be deployed")
+            success = deployer.wait_workload(workload_ids[-1], identity_name=identity.instance_name)
+            if not success:
+                raise DeploymentFailed(
+                    f"Failed to create container on node {selected_node.node_id} {workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.",
+                    solution_uuid=new_solution_uuid,
+                    wid=workload_ids[-1],
+                    identity_name=identity.instance_name,
+                )
+            j.logger.debug(f"threebot container workload {workload_ids[-1]} deployed successfuly")
+
+            trc_log_config = j.core.config.get("LOGGING_SINK", {})
+            if trc_log_config:
+                trc_log_config["channel_name"] = new_solution_info["name"] + "-trc"
+            identity_tid = identity.tid
+            secret = f"{identity_tid}:{uuid.uuid4().hex}"
+            j.logger.debug(f"deploying trc container with secret {secret}")
+            workload_ids.extend(
+                deployer.expose_address(
+                    pool_id=compute_pool_id,
+                    gateway_id=gateway.node_id,
+                    network_name=network_view.name,
+                    local_ip=ip_address,
+                    port=80,
+                    tls_port=443,
+                    trc_secret=secret,
+                    node_id=selected_node.node_id,
+                    reserve_proxy=True,
+                    domain_name=domain,
+                    proxy_pool_id=gateway_pool_id,
+                    solution_uuid=new_solution_uuid,
+                    log_config=trc_log_config,
+                    identity_name=identity.instance_name,
+                    **metadata,
+                )
+            )
+            j.logger.debug(f"wating for trc container workload {workload_ids[-1]} to be deployed")
+            success = deployer.wait_workload(workload_ids[-1], identity_name=identity.instance_name)
+            if not success:
+                raise DeploymentFailed(
+                    f"Failed to create TRC container on node {selected_node.node_id} {workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.",
+                    solution_uuid=new_solution_uuid,
+                    wid=workload_ids[-1],
+                    identity_name=identity.instance_name,
+                )
+            j.logger.debug(f"trc container workload {workload_ids[-1]} deployed successfuly")
+
+            j.logger.debug(f"fetching farm information of pool {compute_pool_id}")
+            farm_id = deployer.get_pool_farm_id(compute_pool_id)
+            farm = zos._explorer.farms.get(farm_id)
+
+            j.logger.debug(f"saving new threebot local config with uuid {new_solution_uuid}")
+            instance_name = f"threebot_{new_solution_uuid}"
+            user_threebot = USER_THREEBOT_FACTORY.get(instance_name)
+            user_threebot.solution_uuid = new_solution_uuid
+            user_threebot.identity_tid = identity.tid
+            user_threebot.name = solution_name
+            user_threebot.owner_tname = threebot.owner_tname
+            user_threebot.farm_name = farm.name
+            user_threebot.state = ThreebotState.RUNNING
+            user_threebot.continent = farm.location.continent
+            user_threebot.explorer_url = identity.explorer_url
+            user_threebot.subdomain_wid = workload_ids[-4]
+            user_threebot.threebot_container_wid = workload_ids[-3]
+            user_threebot.trc_container_wid = workload_ids[-2]
+            user_threebot.reverse_proxy_wid = workload_ids[-1]
+            user_threebot.save()
+            j.logger.debug(f"threebot local config of uuid {new_solution_uuid} saved")
+            j.logger.debug(f"deleting old threebot local config with uuid {solution_uuid}")
+            USER_THREEBOT_FACTORY.delete(f"threebot_{solution_uuid}")
+            j.logger.debug("deployment successful")
+    return user_threebot
diff --git a/jumpscale/packages/threebot_deployer/chats/change_location.py b/jumpscale/packages/threebot_deployer/chats/change_location.py
new file mode 100644
index 0000000000..0bc0d76d28
--- /dev/null
+++ b/jumpscale/packages/threebot_deployer/chats/change_location.py
@@ -0,0 +1,179 @@
+from jumpscale.sals.marketplace import MarketPlaceAppsChatflow, deployer
+from jumpscale.packages.threebot_deployer.bottle.utils import (
+    generate_user_identity,
+    get_threebot_zos,
+    list_threebot_solutions,
+    redeploy_threebot_solution,
+    get_threebot_config_instance,
+)
+from jumpscale.sals.chatflows.chatflows import StopChatFlow
+from jumpscale.packages.threebot_deployer.models.user_solutions import ThreebotState
+from jumpscale.packages.threebot_deployer.models import USER_THREEBOT_FACTORY
+from jumpscale.sals.chatflows.chatflows import chatflow_step
+from textwrap import dedent
+from jumpscale.data.nacl.jsnacl import NACL
+from jumpscale.loader import j
+import random
+
+
+class ThreebotRedeploy(MarketPlaceAppsChatflow):
+    FLIST_URL = "https://hub.grid.tf/ahmed_hanafy_1/ahmedhanafy725-js-sdk-latest.flist"
+    SOLUTION_TYPE = "threebot"  # chatflow used to deploy the solution
+    title = "3Bot"
+    steps = [
+        "choose_name",
+        "enter_password",
+        "choose_location",
+        "choose_deployment_location",
+        "new_expiration",
+        "create_pool",
+        "deploy",
+        "initializing",
+        "success",
+    ]
+
+    @chatflow_step(title="Initializing chatflow")
+    def choose_name(self):
+        self._init_solution()
+        self.branch = "development"
+        all_3bot_solutions = list_threebot_solutions(self.threebot_name)
+        self.stopped_3bots = [
+            threebot for threebot in all_3bot_solutions if threebot["state"] == ThreebotState.STOPPED.value
+        ]
+        self.stopped_names = {threebot["name"]: threebot for threebot in self.stopped_3bots}
+        self.name = self.kwargs["tname"]
+        self.threebot_info = self.stopped_names[self.name]
+        self.pool_id = self.threebot_info["compute_pool"]
+        self.query = {
+            "cru": self.threebot_info["cpu"] + 1,
+            "mru": self.threebot_info["memory"] / 1024 + 1,
+            "sru": self.threebot_info["disk_size"] / 1024 + 0.25,
+        }
+
+    @chatflow_step(title="New Expiration")
+    def new_expiration(self):
+        default_time = j.data.time.utcnow().timestamp + 1209600
+        self.expiration = deployer.ask_expiration(self, default_time)
+
+    def _verify_password(self, password):
+        instance = USER_THREEBOT_FACTORY.get(f"threebot_{self.threebot_info['solution_uuid']}")
+        zos = get_threebot_zos(instance)
+        user = zos._explorer.users.get(instance.identity_tid)
+        words = j.data.encryption.key_to_mnemonic(password.encode().zfill(32))
+        seed = j.data.encryption.mnemonic_to_key(words)
+        pubkey = NACL(seed).get_verify_key_hex()
+        return pubkey == user.pubkey
+
+    @chatflow_step(title="Password")
+    def enter_password(self):
+        message = "Please enter the 3Bot password."
+        self.password = self.secret_ask(message, required=True, max_length=32)
+        while not self._verify_password(self.password):
+            error = message + f"<br><br><code>Incorrect recovery password for 3Bot name {self.name}</code>"
+            self.password = self.secret_ask(error, required=True, max_length=32, md=True)
+
+    def _ask_for_continent(self):
+        self.continent = self.drop_down_choice(
+            "Please select the continent you would like to deploy your 3Bot in.",
+            list(self.farms_by_continent.keys()),
+            required=True,
+        )
+        self.available_farms = self.farms_by_continent[self.continent]
+        self.selected_node = None
+
+    def _ask_for_farm(self):
+        farm_name_dict = {farm.name: farm for farm in self.available_farms}
+        farm_name = self.drop_down_choice(
+            "Please select the farm you would like to deploy your 3Bot in.", list(farm_name_dict.keys()), required=True
+        )
+        self.available_farms = [farm_name_dict[farm_name]]
+        self.selected_node = None
+
+    def _ask_for_node(self):
+        nodes = deployer.get_all_farms_nodes(self.available_farms, **self.query)
+        node_id_dict = {node.node_id: node for node in nodes}
+        node_id = self.drop_down_choice(
+            "Please select the node you would like to deploy your 3Bot on.", list(node_id_dict.keys()), required=True
+        )
+        self.selected_node = node_id_dict[node_id]
+        self.available_farms = [farm for farm in self.available_farms if farm.id == self.selected_node.farm_id]
+
+    @chatflow_step("Reserving a new pool")
+    def create_pool(self):
+        owner = self.threebot_name
+        threebot = get_threebot_config_instance(owner, self.threebot_info["solution_uuid"])
+        zos = get_threebot_zos(threebot)
+        identity = generate_user_identity(threebot, self.password, zos)
+        zos = j.sals.zos.get(identity.instance_name)
+        farm = random.choice(self.available_farms)
+        farm_name = farm.name
+        self.pool_info = deployer.create_3bot_pool(
+            farm_name, self.expiration, currency=self.currency, identity_name=identity.instance_name, **self.query,
+        )
+        if self.pool_info.escrow_information.address.strip() == "":
+            raise StopChatFlow(
+                f"provisioning the pool, invalid escrow information probably caused by a misconfigured, pool creation request was {self.pool_info}"
+            )
+        msg, qr_code = deployer.get_qr_code_payment_info(self.pool_info)
+        deployer.msg_payment_info = msg
+        result = deployer.wait_pool_payment(self, self.pool_info.reservation_id, qr_code=qr_code)
+        if not result:
+            raise StopChatFlow(f"provisioning the pool timed out. pool_id: {self.pool_info.reservation_id}")
+        self.pool_id = self.pool_info.reservation_id
+
+    @chatflow_step(title="Deployment location policy")
+    def choose_location(self):
+        self._get_available_farms()
+        self.farms_by_continent = deployer.group_farms_by_continent(self.available_farms)
+        choices = ["Automatic", "Farm", "Specific node"]
+        if self.farms_by_continent:
+            choices.insert(1, "Continent")
+        self.node_policy = self.single_choice(
+            "Please select the deployment location policy.", choices, required=True, default="Automatic"
+        )
+
+    @chatflow_step(title="Deployment location")
+    def choose_deployment_location(self):
+        if self.node_policy == "Continent":
+            self._ask_for_continent()
+        elif self.node_policy == "Farm":
+            self._ask_for_farm()
+        elif self.node_policy == "Specific node":
+            self._ask_for_node()
+
+    @chatflow_step(title="Deploying", disable_previous=True)
+    def deploy(self):
+        self.md_show_update("Starting your 3Bot...")
+        node_id = self.selected_node.node_id if self.selected_node else None
+        redeploy_threebot_solution(
+            self.username,
+            self.threebot_info["solution_uuid"],
+            self.password,
+            compute_pool_id=self.pool_id,
+            node_id=node_id,
+            solution_info={"flist": self.FLIST_URL, "branch": self.branch},
+        )
+
+    @chatflow_step(title="Initializing", disable_previous=True)
+    def initializing(self):
+        self.md_show_update("Initializing your 3Bot ...")
+        self.domain = self.threebot_info["domain"]
+        self.threebot_url = f"https://{self.domain}/admin"
+        if not j.sals.reservation_chatflow.wait_http_test(
+            self.threebot_url, timeout=600, verify=not j.config.get("TEST_CERT")
+        ):
+            self.stop(f"Failed to initialize 3Bot on {self.threebot_url} , please contact support")
+        self.domain = f"{self.domain}/admin"
+
+    @chatflow_step(title="Success", disable_previous=True, final_step=True)
+    def success(self):
+        display_name = self.threebot_info["name"]
+        message = f"""\
+        # Your 3Bot instance {display_name} has started
+        <br />\n
+        - You can access it via the browser using: <a href="https://{self.domain}" target="_blank">https://{self.domain}</a>
+        """
+        self.md_show(dedent(message), md=True)
+
+
+chat = ThreebotRedeploy
diff --git a/jumpscale/packages/threebot_deployer/chats/change_size.py b/jumpscale/packages/threebot_deployer/chats/change_size.py
new file mode 100644
index 0000000000..82b4b6cc7a
--- /dev/null
+++ b/jumpscale/packages/threebot_deployer/chats/change_size.py
@@ -0,0 +1,123 @@
+from jumpscale.sals.marketplace import MarketPlaceAppsChatflow, deployer
+from jumpscale.packages.threebot_deployer.bottle.utils import list_threebot_solutions, redeploy_threebot_solution
+from jumpscale.packages.threebot_deployer.models.user_solutions import ThreebotState
+from jumpscale.packages.threebot_deployer.models import USER_THREEBOT_FACTORY
+from jumpscale.sals.chatflows.chatflows import chatflow_step
+from textwrap import dedent
+from jumpscale.data.nacl.jsnacl import NACL
+from jumpscale.loader import j
+
+
+FLAVORS = {
+    "Silver": {"cru": 1, "mru": 2, "sru": 2},
+    "Gold": {"cru": 2, "mru": 4, "sru": 4},
+    "Platinum": {"cru": 4, "mru": 8, "sru": 8},
+}
+
+
+class ThreebotRedeploy(MarketPlaceAppsChatflow):
+    FLIST_URL = "https://hub.grid.tf/ahmed_hanafy_1/ahmedhanafy725-js-sdk-latest.flist"
+    SOLUTION_TYPE = "threebot"  # chatflow used to deploy the solution
+    title = "3Bot"
+    steps = [
+        "choose_name",
+        "enter_password",
+        "choose_flavor",
+        "new_expiration",
+        "solution_extension",
+        "deploy",
+        "initializing",
+        "success",
+    ]
+
+    @chatflow_step(title="Initializing chatflow")
+    def choose_name(self):
+        self._init_solution()
+        self.branch = "development"
+        all_3bot_solutions = list_threebot_solutions(self.threebot_name)
+        self.stoped_3bots = [
+            threebot for threebot in all_3bot_solutions if threebot["state"] == ThreebotState.STOPPED.value
+        ]
+        self.stopped_names = {threebot["name"]: threebot for threebot in self.stoped_3bots}
+        self.name = self.kwargs["tname"]
+        self.threebot_info = self.stopped_names[self.name]
+        self.pool_id = self.threebot_info["compute_pool"]
+
+    @chatflow_step(title="Choose size")
+    def choose_flavor(self):
+        self._choose_flavor(FLAVORS)
+        self.query = self.flavor_resources
+        self.cpu = self.query["cru"]
+        self.memory = self.query["mru"] * 1024
+        self.disk_size = self.query["sru"] * 1024
+        self.query["cru"] += 1
+        self.query["mru"] += 1
+        self.query["cru"] += 0.25
+
+    @chatflow_step(title="New Expiration")
+    def new_expiration(self):
+        self.pool = j.sals.zos.get().pools.get(self.pool_id)
+        cu, su = deployer.calculate_capacity_units(**self.query)
+        expiration_time = min(self.pool.cus / cu, self.pool.sus / su)
+        if expiration_time < 60 * 60:
+            default_time = j.data.time.utcnow().timestamp + 1209600
+            self.expiration = deployer.ask_expiration(
+                self, default_time, pool_empty_at=j.data.time.utcnow().timestamp + expiration_time
+            )
+        else:
+            self.expiration = 0
+
+    def _verify_password(self, password):
+        name = f"{self.threebot_name}_{self.name}"
+        explorer = j.clients.explorer.get_by_url("https://explorer.testnet.grid.tf/api/v1")  # Fix
+        user = explorer.users.get(name=name)
+        words = j.data.encryption.key_to_mnemonic(password.encode().zfill(32))
+        seed = j.data.encryption.mnemonic_to_key(words)
+        pubkey = NACL(seed).get_verify_key_hex()
+        return pubkey == user.pubkey
+
+    @chatflow_step(title="Password")
+    def enter_password(self):
+        message = "Please enter the 3Bot password."
+        self.password = self.secret_ask(message, required=True, max_length=32)
+        while not self._verify_password(self.password):
+            error = message + f"<br><br><code>Incorrect recovery password for 3Bot name {self.name}</code>"
+            self.password = self.secret_ask(error, required=True, max_length=32, md=True)
+
+    @chatflow_step(title="Deploying", disable_previous=True)
+    def deploy(self):
+        self.md_show_update("Starting your 3Bot...")
+        solution_info = {
+            "cpu": self.cpu,
+            "memory": self.memory,
+            "disk_size": self.disk_size,
+            "flist": self.FLIST_URL,
+            "branch": self.branch,
+        }
+        redeploy_threebot_solution(
+            self.username, self.threebot_info["solution_uuid"], self.password, solution_info=solution_info
+        )
+
+    @chatflow_step(title="Initializing", disable_previous=True)
+    def initializing(self):
+        self.md_show_update("Initializing your 3Bot ...")
+        self.domain = self.threebot_info["domain"]
+        self.threebot_url = f"https://{self.domain}/admin"
+        if not j.sals.reservation_chatflow.wait_http_test(
+            self.threebot_url, timeout=600, verify=not j.config.get("TEST_CERT")
+        ):
+            self.stop(f"Failed to initialize 3Bot on {self.threebot_url} , please contact support")
+        self.domain = f"{self.domain}/admin"
+
+    @chatflow_step(title="Success", disable_previous=True, final_step=True)
+    def success(self):
+        display_name = self.threebot_info["name"]
+        message = f"""\
+        # Your 3Bot instance {display_name} has started
+        <br />\n
+        - You can access it via the browser using: <a href="https://{self.domain}" target="_blank">https://{self.domain}</a>
+        """
+        self.md_show(dedent(message), md=True)
+
+
+chat = ThreebotRedeploy
diff --git a/jumpscale/packages/threebot_deployer/chats/extend.py b/jumpscale/packages/threebot_deployer/chats/extend.py
deleted file mode 100644
index 77d95b0b4c..0000000000
--- a/jumpscale/packages/threebot_deployer/chats/extend.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from jumpscale.loader import j
-from jumpscale.sals.chatflows.chatflows import chatflow_step
-from jumpscale.sals.marketplace import MarketPlaceAppsChatflow, solutions
-
-
-class ExtendThreebot(MarketPlaceAppsChatflow):
-
-    title = "Extend 3Bot"
-    steps = ["select_threebot", "new_expiration", "solution_extension", "success"]
-
-    @chatflow_step(title="Select 3Bot")
-    def select_threebot(self):
-        self._validate_user()
-        self.query = {"cru": 2, "mru": 2, "sru": 2.25}
-        self.threebot_name = self.user_info()["username"]
-        self.explorer = j.core.identity.me.explorer
-        self.threebot_workloads = solutions.list_solutions(self.threebot_name, "threebot")
-        self.threebot_names = [s["Name"] for s in self.threebot_workloads]
-        self._threebots_dict = dict(zip(self.threebot_names, self.threebot_workloads))
-        self.threebot_selected = self.single_choice(
-            "Choose the 3Bot you would like to extend", self.threebot_names, required=True
-        )
-        self.pool_id = self._threebots_dict[self.threebot_selected]["Pool"]
-        self.pool = j.sals.zos.get().pools.get(self.pool_id)
-
-    @chatflow_step(title="Success", final_step=True)
-    def success(self):
-        self.md_show("Your 3Bot has been extended successfully.")
-
-
-chat = ExtendThreebot
diff --git a/jumpscale/packages/threebot_deployer/chats/restart_threebot.py b/jumpscale/packages/threebot_deployer/chats/restart_threebot.py
new file mode 100644
index 0000000000..3e26f0f57a
--- /dev/null
+++ b/jumpscale/packages/threebot_deployer/chats/restart_threebot.py
@@ -0,0 +1,109 @@
+from jumpscale.sals.marketplace import MarketPlaceAppsChatflow, deployer
+from jumpscale.packages.threebot_deployer.bottle.utils import (
+    list_threebot_solutions,
+    redeploy_threebot_solution,
+    get_threebot_zos,
+)
+from jumpscale.packages.threebot_deployer.models.user_solutions import ThreebotState
+from jumpscale.packages.threebot_deployer.models import USER_THREEBOT_FACTORY
+from jumpscale.sals.chatflows.chatflows import chatflow_step
+from textwrap import dedent
+from jumpscale.data.nacl.jsnacl import NACL
+from jumpscale.loader import j
+
+
+class ThreebotRedeploy(MarketPlaceAppsChatflow):
+    FLIST_URL = "https://hub.grid.tf/ahmed_hanafy_1/ahmedhanafy725-js-sdk-latest.flist"
+    SOLUTION_TYPE = "threebot"  # chatflow used to deploy the solution
+    title = "3Bot"
+    steps = [
+        "choose_name",
+        "enter_password",
+        "new_expiration",
+        "solution_extension",
+        "deploy",
+        "initializing",
+        "success",
+    ]
+
+    @chatflow_step(title="Initializing chatflow")
+    def choose_name(self):
+        self._init_solution()
+        self.branch = "development"
+        all_3bot_solutions = list_threebot_solutions(self.threebot_name)
+        self.non_running_3bots = [
+            threebot for threebot in all_3bot_solutions if threebot["state"] != ThreebotState.RUNNING.value
+        ]
+        self.non_running_names = {threebot["name"]: threebot for threebot in self.non_running_3bots}
+        self.name = self.kwargs["tname"]
+        self.threebot_info = self.non_running_names[self.name]
+        self.pool_id = self.threebot_info["compute_pool"]
+        self.query = {
+            "cru": self.threebot_info["cpu"] + 1,
+            "mru": self.threebot_info["memory"] / 1024 + 1,
+            "sru": self.threebot_info["disk_size"] / 1024 + 0.25,
+        }
+
+    @chatflow_step(title="New Expiration")
+    def new_expiration(self):
+        self.pool = j.sals.zos.get().pools.get(self.pool_id)
+        cu, su = deployer.calculate_capacity_units(**self.query)
+        expiration_time = min(self.pool.cus / cu, self.pool.sus / su)
+        if expiration_time < 60 * 60:
+            default_time = j.data.time.utcnow().timestamp + 1209600
+            self.expiration = deployer.ask_expiration(
+                self, default_time, pool_empty_at=j.data.time.utcnow().timestamp + expiration_time
+            )
+        else:
+            self.expiration = 0
+
+    def _verify_password(self, password):
+        instance = USER_THREEBOT_FACTORY.get(f"threebot_{self.threebot_info['solution_uuid']}")
+        zos = get_threebot_zos(instance)
+        user = zos._explorer.users.get(instance.identity_tid)
+        words = j.data.encryption.key_to_mnemonic(password.encode().zfill(32))
+        seed = j.data.encryption.mnemonic_to_key(words)
+        pubkey = NACL(seed).get_verify_key_hex()
+        return pubkey == user.pubkey
+
+    @chatflow_step(title="Password")
+    def enter_password(self):
+        message = "Please enter the 3Bot password."
+        self.password = self.secret_ask(message, required=True, max_length=32)
+        while not self._verify_password(self.password):
+            error = message + f"<br><br><code>Incorrect recovery password for 3Bot name {self.name}</code>"
+            self.password = self.secret_ask(error, required=True, max_length=32, md=True)
+
+    @chatflow_step(title="Deploying", disable_previous=True)
+    def deploy(self):
+        self.md_show_update("Starting your 3Bot...")
+        redeploy_threebot_solution(
+            self.username,
+            self.threebot_info["solution_uuid"],
+            self.password,
+            solution_info={"flist": self.FLIST_URL, "branch": self.branch},
+        )
+
+    @chatflow_step(title="Initializing", disable_previous=True)
+    def initializing(self):
+        self.md_show_update("Initializing your 3Bot ...")
+        self.domain = self.threebot_info["domain"]
+        self.threebot_url = f"https://{self.domain}/admin"
+        if not j.sals.reservation_chatflow.wait_http_test(
+            self.threebot_url, timeout=600, verify=not j.config.get("TEST_CERT")
+        ):
+            self.stop(f"Failed to initialize 3Bot on {self.threebot_url} , please contact support")
+        self.domain = f"{self.domain}/admin"
+
+    @chatflow_step(title="Success", disable_previous=True, final_step=True)
+    def success(self):
+        display_name = self.threebot_info["name"]
+        message = f"""\
+        # Your 3Bot instance {display_name} has started
+        <br />\n
+        - You can access it via the browser using: <a href="https://{self.domain}" target="_blank">https://{self.domain}</a>
+        """
+        self.md_show(dedent(message), md=True)
+
+
+chat = ThreebotRedeploy
diff --git a/jumpscale/packages/threebot_deployer/chats/threebot.py b/jumpscale/packages/threebot_deployer/chats/threebot.py
index 0b67eb4c7e..86a4fc50b4 100644
--- a/jumpscale/packages/threebot_deployer/chats/threebot.py
+++ b/jumpscale/packages/threebot_deployer/chats/threebot.py
@@ -1,13 +1,22 @@
 import uuid
+import random
 from textwrap import dedent
 
 from jumpscale.data.nacl.jsnacl import NACL
 from jumpscale.loader import j
-from jumpscale.packages.threebot_deployer.models.backup_tokens_sal import BACKUP_MODEL_FACTORY
+from jumpscale.packages.threebot_deployer.bottle.utils import list_threebot_solutions, threebot_identity_context
+from jumpscale.packages.threebot_deployer.models import BACKUP_MODEL_FACTORY, USER_THREEBOT_FACTORY
+from jumpscale.packages.threebot_deployer.models.user_solutions import ThreebotState
 from jumpscale.sals.chatflows.chatflows import StopChatFlow, chatflow_step
-from jumpscale.sals.marketplace import MarketPlaceAppsChatflow, deployer, solutions
+from jumpscale.sals.marketplace import MarketPlaceAppsChatflow, deployer
 from jumpscale.sals.reservation_chatflow import DeploymentFailed, deployment_context
 
+FLAVORS = {
+    "Silver": {"cru": 1, "mru": 2, "sru": 2},
+    "Gold": {"cru": 2, "mru": 4, "sru": 4},
+    "Platinum": {"cru": 4, "mru": 8, "sru": 8},
+}
+
 
 class ThreebotDeploy(MarketPlaceAppsChatflow):
     FLIST_URL = "https://hub.grid.tf/ahmed_hanafy_1/ahmedhanafy725-js-sdk-latest.flist"
@@ -16,8 +25,11 @@ class ThreebotDeploy(MarketPlaceAppsChatflow):
     steps = [
         "create_or_recover",
         "get_solution_name",
+        "deployer_info",
         "upload_public_key",
         "set_backup_password",
+        "choose_location",
+        "choose_deployment_location",
         "email_settings",
         "infrastructure_setup",
         "reservation",
@@ -28,7 +40,7 @@ class ThreebotDeploy(MarketPlaceAppsChatflow):
         "success",
     ]
 
-    RECOVER_NAME_MESSAGE = "Please enter the 3Bot name you want to recover"
+    RECOVER_NAME_MESSAGE = "Please enter the 3Bot name you want to import"
     CREATE_NAME_MESSAGE = "Just like humans, each 3Bot needs their own unique identity to exist on top of the Threefold Grid. Please enter a name for your new 3Bot. This name will be used as the web address that could give you access to your 3Bot anytime."
 
     def _threebot_start(self):
@@ -48,12 +60,81 @@ def _threebot_start(self):
         self.retries = 3
         self.allow_custom_domain = False
         self.custom_domain = False
+        self.currency = "TFT"
+        self.identity_name = j.core.identity.me.instance_name
+
+    def _create_identities(self):
+        instance_name = self.solution_name
+        threebot_name = self.threebot_name
+        tname = f"{threebot_name}_{instance_name}"
+        email = f"{tname}@threefold.me"
+        words = j.data.encryption.key_to_mnemonic(self.backup_password.encode().zfill(32))
+        self.mainnet_identity_name = f"{tname}_main"
+        self.testnet_identity_name = f"{tname}_test"
+        if "testnet" in j.core.identity.me.explorer_url:
+            self.identity_name = self.testnet_identity_name
+        else:
+            self.identity_name = self.mainnet_identity_name
+        try:
+            identity_main = j.core.identity.get(
+                self.mainnet_identity_name,
+                tname=tname,
+                email=email,
+                words=words,
+                explorer_url="https://explorer.grid.tf/api/v1",
+            )
+            identity_test = j.core.identity.get(
+                self.testnet_identity_name,
+                tname=tname,
+                email=email,
+                words=words,
+                explorer_url="https://explorer.testnet.grid.tf/api/v1",
+            )
+            identities = [identity_main, identity_test]
+            for identity in identities:
+                tname = identity.tname
+                identity.admins.append(f"{threebot_name}.3bot")
+                identity.register()
+                identity.save()
+                if identity.instance_name != self.identity_name:
+                    j.core.identity.delete(identity.instance_name)
+
+        except:
+            raise StopChatFlow(
+                f"Couldn't register new identites with the given name {tname}. Make sure you entered the correct password."
+            )
+
+    def _get_pool(self):
+        self._get_available_farms(only_one=False, identity_name=self.identity_name)
+        self._select_farms()
+        self._select_pool_node()
+        self.pool_info = deployer.create_3bot_pool(
+            self.farm_name, self.expiration, currency=self.currency, identity_name=self.identity_name, **self.query
+        )
+        if self.pool_info.escrow_information.address.strip() == "":
+            raise StopChatFlow(
+                f"provisioning the pool, invalid escrow information probably caused by a misconfigured, pool creation request was {self.pool_info}"
+            )
+        deployer.pay_for_pool(self.pool_info)
+        result = deployer.wait_demo_payment(self, self.pool_info.reservation_id)
+        if not result:
+            raise StopChatFlow(f"provisioning the pool timed out. pool_id: {self.pool_info.reservation_id}")
+        self.wgcfg = deployer.init_new_user_network(
+            self,
+            self.identity_name,
+            self.pool_info.reservation_id,
+            identity_name=self.identity_name,
+            network_name="management",
+        )
+        self.pool_id = self.pool_info.reservation_id
+        self.network_view = deployer.get_network_view("management", identity_name=self.identity_name)
 
     @chatflow_step(title="Welcome")
     def create_or_recover(self):
+        self.recovery_network_name = "testnet" if "test" not in j.core.identity.me.explorer_url else "mainnet"
         self.action = self.single_choice(
-            "Would you like to create a new 3Bot instance, or recover an existing one?",
-            ["Create", "Recover"],
+            f"Would you like to create a new 3Bot instance, or import one from {self.recovery_network_name}?",
+            ["Create", "Import"],
             required=True,
         )
 
@@ -61,13 +142,13 @@ def create_or_recover(self):
     def get_solution_name(self):
         self._threebot_start()
         valid = False
-        name_message = self.RECOVER_NAME_MESSAGE if self.action == "Recover" else self.CREATE_NAME_MESSAGE
+        name_message = self.RECOVER_NAME_MESSAGE if self.action == "Import" else self.CREATE_NAME_MESSAGE
         while not valid:
             self.solution_name = self.string_ask(name_message, required=True, field="name", is_identifier=True)
-            threebot_solutions = solutions.list_threebot_solutions(self.solution_metadata["owner"], sync=False)
+            threebot_solutions = list_threebot_solutions(self.solution_metadata["owner"])
             valid = True
             for sol in threebot_solutions:
-                if sol["Name"] == self.solution_name:
+                if sol["name"] == self.solution_name:
                     valid = False
                     self.md_show("The specified 3Bot name already exists. please choose another name.")
                     break
@@ -75,19 +156,26 @@ def get_solution_name(self):
             if valid and self.action == "Create" and self._existing_3bot():
                 valid = False
                 self.md_show(
-                    "The specified 3Bot name was deployed before. Please go to the previous step and choose recover or enter a new name."
+                    f"The specified 3Bot name was deployed before on {self.recovery_network_name}. Please go to the previous step and choose import or enter a new name."
                 )
 
-            if valid and self.action == "Recover" and not self._existing_3bot():
+            if valid and self.action == "Import" and not self._existing_3bot():
                 valid = False
                 self.md_show("The specified 3Bot name doesn't exist.")
         self.backup_model = BACKUP_MODEL_FACTORY.get(f"{self.solution_name}_{self.threebot_name}")
 
+    @chatflow_step(title="Deployer Information")
+    def deployer_info(self):
+        self.user_email = self.user_info()["email"]
+        self._choose_flavor(FLAVORS)
+        self.vol_size = self.flavor_resources["sru"]
+        self.container_resources = self.flavor_resources
+
     @chatflow_step(title="SSH key (Optional)")
     def upload_public_key(self):
         self.public_key = (
             self.upload_file(
-                "Please upload your public ssh key, this will allow you to access your threebot container using ssh",
+                "Please upload your public ssh key, this will allow you to access your threebot container using ssh"
             )
             or ""
         )
@@ -109,15 +197,77 @@ def _verify_password(self, password):
         pubkey = NACL(seed).get_verify_key_hex()
         return pubkey == user.pubkey
 
+    def _select_node(self):
+        if self.node_policy != "Specific node":
+            return super()._select_node()
+
+    def _select_pool_node(self):
+        if self.node_policy == "Specific node":
+            self.pool_node_id = self.selected_node
+        else:
+            super()._select_pool_node()
+
+    def _select_farm(self):
+        if self.node_policy == "Automatic":
+            super()._select_farms()
+        else:
+            self.farm_name = random.choice(self.available_farms).name
+            self.pool_farm_name = self.farm_name
+
+    @chatflow_step(title="Deployment location policy")
+    def choose_location(self):
+        self._get_available_farms()
+        self.farms_by_continent = deployer.group_farms_by_continent(self.available_farms)
+        choices = ["Automatic", "Farm", "Specific node"]
+        if self.farms_by_continent:
+            choices.insert(1, "Continent")
+        self.node_policy = self.single_choice(
+            "Please select the deployment location policy.", choices, required=True, default="Automatic"
+        )
+
+    def _ask_for_continent(self):
+        self.continent = self.drop_down_choice(
+            "Please select the continent you would like to deploy your 3Bot in.",
+            list(self.farms_by_continent.keys()),
+            required=True,
+        )
+        self.available_farms = self.farms_by_continent[self.continent]
+
+    def _ask_for_farm(self):
+        farm_name_dict = {farm.name: farm for farm in self.available_farms}
+        farm_name = self.drop_down_choice(
+            "Please select the farm you would like to deploy your 3Bot in.", list(farm_name_dict.keys()), required=True
+        )
+        self.available_farms = [farm_name_dict[farm_name]]
+
+    def _ask_for_node(self):
+        nodes = deployer.get_all_farms_nodes(self.available_farms, **self.query)
+        node_id_dict = {node.node_id: node for node in nodes}
+        node_id = self.drop_down_choice(
+            "Please select the node you would like to deploy your 3Bot on.", list(node_id_dict.keys()), required=True
+        )
+        self.selected_node = node_id_dict[node_id]
+        self.available_farms = [farm for farm in self.available_farms if farm.id == self.selected_node.farm_id]
+
+    @chatflow_step(title="Deployment location")
+    def choose_deployment_location(self):
+        if self.node_policy == "Continent":
+            self._ask_for_continent()
+        elif self.node_policy == "Farm":
+            self._ask_for_farm()
+        elif self.node_policy == "Specific node":
+            self._ask_for_node()
+        self._create_identities()
+
     @chatflow_step(title="Recovery Password")
     def set_backup_password(self):
         message = (
             "Please enter the recovery password"
-            if self.action == "Recover"
+            if self.action == "Import"
             else "Please create a secure password for your new 3Bot. This password is used to recover your hosted 3Bot."
         )
         self.backup_password = self.secret_ask(message, required=True, max_length=32)
-        while self.action == "Recover" and not self._verify_password(self.backup_password):
+        while self.action == "Import" and not self._verify_password(self.backup_password):
             error = message + f"<br><br><code>Incorrect recovery password for 3Bot name {self.solution_name}</code>"
             self.backup_password = self.secret_ask(error, required=True, max_length=32, md=True)
 
@@ -144,121 +294,146 @@ def payment_currency(self):
             required=True,
         )
 
-    @deployment_context()
     def _deploy(self):
-        # 1- add node to network
-        metadata = {"form_info": {"Solution name": self.solution_name, "chatflow": "threebot"}}
-        self.solution_metadata.update(metadata)
-        self.workload_ids = []
-        deploying_message = f"""\
-        # Deploying your 3Bot...\n\n
-        <br>It will usually take a few minutes to succeed. Please wait patiently.\n
-        You will be automatically redirected to the next step once succeeded.
-        """
-        self.md_show_update(dedent(deploying_message), md=True)
+        with threebot_identity_context(self.identity_name):
+            with deployment_context():
+                # 1- add node to network
+                metadata = {"form_info": {"Solution name": self.solution_name, "chatflow": "threebot"}}
+                self.solution_metadata.update(metadata)
+                self.workload_ids = []
+                deploying_message = f"""\
+                # Deploying your 3Bot...\n\n
+                <br>It will usually take a few minutes to succeed. Please wait patiently.\n
+                You will be automatically redirected to the next step once succeeded.
+                """
+                self.md_show_update(dedent(deploying_message), md=True)
+
+                # 2- reserve subdomain
+                if not self.custom_domain:
+                    self.workload_ids.append(
+                        deployer.create_subdomain(
+                            pool_id=self.gateway_pool.pool_id,
+                            gateway_id=self.gateway.node_id,
+                            subdomain=self.domain,
+                            addresses=self.addresses,
+                            solution_uuid=self.solution_id,
+                            identity_name=self.identity_name,
+                            **self.solution_metadata,
+                        )
+                    )
+
+                    success = deployer.wait_workload(self.workload_ids[-1], identity_name=self.identity_name)
+                    if not success:
+                        raise DeploymentFailed(
+                            f"Failed to create subdomain {self.domain} on gateway {self.gateway.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.",
+                            wid=self.workload_ids[-1],
+                            identity_name=self.identity_name,
+                        )
+                test_cert = j.config.get("TEST_CERT")
+
+                # Generate a one-time token to create a user for backup
+                backup_token = str(j.data.idgenerator.idgenerator.uuid.uuid4())
+                self.backup_model.token = backup_token
+                self.backup_model.tname = self.solution_metadata["owner"]
+                self.backup_model.save()
+                # 3- deploy threebot container
+                environment_vars = {
+                    "SDK_VERSION": self.branch,
+                    "INSTANCE_NAME": self.solution_name,
+                    "THREEBOT_NAME": self.threebot_name,
+                    "DOMAIN": self.domain,
+                    "SSHKEY": self.public_key,
+                    "TEST_CERT": "true" if test_cert else "false",
+                    "MARKETPLACE_URL": f"https://{j.sals.nginx.main.websites.threebot_deployer_threebot_deployer_root_proxy_443.domain}/",
+                    "DEFAULT_IDENTITY": "test" if "test" in j.core.identity.me.explorer_url else "main",
+                    # email settings
+                    "EMAIL_HOST": self.email_host,
+                    "EMAIL_HOST_USER": self.email_host_user,
+                    "EMAIL_HOST_PASSWORD": self.email_host_password,
+                    "ESCALATION_MAIL": self.escalation_mail_address,
+                }
+                self.network_view = self.network_view.copy()
+
+                ## Container logs
+                log_config = j.core.config.get("LOGGING_SINK", {})
+                if log_config:
+                    log_config["channel_name"] = self.solution_name
+
+                self.workload_ids.append(
+                    deployer.deploy_container(
+                        pool_id=self.pool_id,
+                        node_id=self.selected_node.node_id,
+                        network_name=self.network_view.name,
+                        ip_address=self.ip_address,
+                        flist=self.FLIST_URL,
+                        env=environment_vars,
+                        cpu=self.container_resources["cru"],
+                        memory=self.container_resources["mru"] * 1024,
+                        disk_size=self.container_resources["sru"] * 1024,
+                        secret_env={"BACKUP_PASSWORD": self.backup_password, "BACKUP_TOKEN": backup_token},
+                        interactive=False,
+                        log_config=log_config,
+                        solution_uuid=self.solution_id,
+                        identity_name=self.identity_name,
+                        **self.solution_metadata,
+                    )
+                )
+                success = deployer.wait_workload(self.workload_ids[-1], identity_name=self.identity_name)
+                if not success:
+                    raise DeploymentFailed(
+                        f"Failed to create container on node {self.selected_node.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.",
+                        solution_uuid=self.solution_id,
+                        wid=self.workload_ids[-1],
+                        identity_name=self.identity_name,
+                    )
 
-        # 2- reserve subdomain
-        if not self.custom_domain:
-            self.workload_ids.append(
-                deployer.create_subdomain(
-                    pool_id=self.gateway_pool.pool_id,
+                # 4- expose threebot container
+                wid, proxy_id = deployer.expose_address(
+                    pool_id=self.pool_id,
                     gateway_id=self.gateway.node_id,
-                    subdomain=self.domain,
-                    addresses=self.addresses,
+                    network_name=self.network_view.name,
+                    local_ip=self.ip_address,
+                    port=80,
+                    tls_port=443,
+                    trc_secret=self.secret,
+                    node_id=self.selected_node.node_id,
+                    reserve_proxy=True,
+                    domain_name=self.domain,
+                    proxy_pool_id=self.gateway_pool.pool_id,
                     solution_uuid=self.solution_id,
+                    log_config=self.trc_log_config,
+                    identity_name=self.identity_name,
                     **self.solution_metadata,
                 )
-            )
+                self.workload_ids.append(wid)
+                self.workload_ids.append(proxy_id)
+                success = deployer.wait_workload(self.workload_ids[-1], identity_name=self.identity_name)
+                if not success:
+                    raise DeploymentFailed(
+                        f"Failed to create TRC container on node {self.selected_node.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.",
+                        solution_uuid=self.solution_id,
+                        wid=self.workload_ids[-1],
+                        identity_name=self.identity_name,
+                    )
+                self.threebot_url = f"https://{self.domain}/admin"
 
-            success = deployer.wait_workload(self.workload_ids[-1])
-            if not success:
-                raise DeploymentFailed(
-                    f"Failed to create subdomain {self.domain} on gateway {self.gateway.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.",
-                    wid=self.workload_ids[-1],
-                )
-        test_cert = j.config.get("TEST_CERT")
-
-        # Generate a one-time token to create a user for backup
-        backup_token = str(j.data.idgenerator.idgenerator.uuid.uuid4())
-        self.backup_model.token = backup_token
-        self.backup_model.tname = self.solution_metadata["owner"]
-        self.backup_model.save()
-
-        # 3- deploy threebot container
-        environment_vars = {
-            "SDK_VERSION": self.branch,
-            "INSTANCE_NAME": self.solution_name,
-            "THREEBOT_NAME": self.threebot_name,
-            "DOMAIN": self.domain,
-            "SSHKEY": self.public_key,
-            "TEST_CERT": "true" if test_cert else "false",
-            "MARKETPLACE_URL": f"https://{j.sals.nginx.main.websites.threebot_deployer_threebot_deployer_root_proxy_443.domain}/",
-            # email settings
-            "EMAIL_HOST": self.email_host,
-            "EMAIL_HOST_USER": self.email_host_user,
-            "EMAIL_HOST_PASSWORD": self.email_host_password,
-            "ESCALATION_MAIL": self.escalation_mail_address,
-        }
-        self.network_view = self.network_view.copy()
-
-        ## Container logs
-        log_config = j.core.config.get("LOGGING_SINK", {})
-        if log_config:
-            log_config["channel_name"] = self.solution_name
-
-        self.workload_ids.append(
-            deployer.deploy_container(
-                pool_id=self.pool_id,
-                node_id=self.selected_node.node_id,
-                network_name=self.network_view.name,
-                ip_address=self.ip_address,
-                flist=self.FLIST_URL,
-                env=environment_vars,
-                cpu=self.container_resources["cru"],
-                memory=self.container_resources["mru"] * 1024,
-                disk_size=self.container_resources["sru"] * 1024,
-                secret_env={"BACKUP_PASSWORD": self.backup_password, "BACKUP_TOKEN": backup_token},
-                interactive=False,
-                log_config=log_config,
-                solution_uuid=self.solution_id,
-                **self.solution_metadata,
-            )
-        )
-        success = deployer.wait_workload(self.workload_ids[-1])
-        if not success:
-            raise DeploymentFailed(
-                f"Failed to create container on node {self.selected_node.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.",
-                solution_uuid=self.solution_id,
-                wid=self.workload_ids[-1],
-            )
-
-        # 4- expose threebot container
-        self.workload_ids.append(
-            deployer.expose_address(
-                pool_id=self.pool_id,
-                gateway_id=self.gateway.node_id,
-                network_name=self.network_view.name,
-                local_ip=self.ip_address,
-                port=80,
-                tls_port=443,
-                trc_secret=self.secret,
-                node_id=self.selected_node.node_id,
-                reserve_proxy=True,
-                domain_name=self.domain,
-                proxy_pool_id=self.gateway_pool.pool_id,
-                solution_uuid=self.solution_id,
-                log_config=self.trc_log_config,
-                **self.solution_metadata,
-            )
-        )
-        success = deployer.wait_workload(self.workload_ids[-1])
-        if not success:
-            raise DeploymentFailed(
-                f"Failed to create TRC container on node {self.selected_node.node_id} {self.workload_ids[-1]}. The resources you paid for will be re-used in your upcoming deployments.",
-                solution_uuid=self.solution_id,
-                wid=self.workload_ids[-1],
-            )
-        self.threebot_url = f"https://{self.domain}/admin"
+                instance_name = f"threebot_{self.solution_id}"
+                user_threebot = USER_THREEBOT_FACTORY.get(instance_name)
+                user_threebot.solution_uuid = self.solution_id
+                user_threebot.identity_tid = j.core.identity.get(self.identity_name).tid
+                user_threebot.name = self.solution_name
+                user_threebot.owner_tname = self.threebot_name
+                user_threebot.farm_name = self.farm_name
+                user_threebot.state = ThreebotState.RUNNING
+                if hasattr(self, "continent"):
+                    user_threebot.continent = self.continent
+                if not self.custom_domain:
+                    user_threebot.subdomain_wid = self.workload_ids[-4]
+                user_threebot.threebot_container_wid = self.workload_ids[-3]
+                user_threebot.trc_container_wid = self.workload_ids[-2]
+                user_threebot.reverse_proxy_wid = self.workload_ids[-1]
+                user_threebot.explorer_url = j.core.identity.get(self.identity_name).explorer_url
+                user_threebot.save()
 
     @chatflow_step(title="Initializing", disable_previous=True)
     def initializing(self):
diff --git a/jumpscale/packages/threebot_deployer/frontend/api.js b/jumpscale/packages/threebot_deployer/frontend/api.js
index 0c654a8925..0f856bd90e 100644
--- a/jumpscale/packages/threebot_deployer/frontend/api.js
+++ b/jumpscale/packages/threebot_deployer/frontend/api.js
@@ -23,29 +23,30 @@ const apiClient = {
     },
   },
   solutions: {
-    getDeployed: () => {
+    getAllThreebots: () => {
       return axios({
         url: `/threebot_deployer/api/threebots/list`,
         method: "get",
         headers: { 'Content-Type': 'application/json' }
       })
+
     },
-    cancelReservation: (wids) => {
+    stopThreebot: (uuid, password) => {
       return axios({
-        url: `/threebot_deployer/api/solutions/cancel`,
+        url: `/threebot_deployer/api/threebots/stop`,
         headers: { 'Content-Type': 'application/json' },
-        data: { wids: wids },
+        data: { uuid: uuid , password: password },
         method: "post"
       })
     },
-    destroyBackup: (threebotName) => {
+    destroyThreebot: (uuid, password) => {
       return axios({
-        url: `/threebot_deployer/backup/destroy`,
+        url: `/threebot_deployer/api/threebots/destroy`,
         headers: { 'Content-Type': 'application/json' },
-        data: { "threebot_name": threebotName },
+        data: { uuid: uuid, password: password },
         method: "post"
       })
-    }
+    },
   },
   license: {
     accept: () => {
diff --git a/jumpscale/packages/threebot_deployer/frontend/components/base/Table.vue b/jumpscale/packages/threebot_deployer/frontend/components/base/Table.vue
new file mode 100644
index 0000000000..2e19dec869
--- /dev/null
+++ b/jumpscale/packages/threebot_deployer/frontend/components/base/Table.vue
@@ -0,0 +1,184 @@
+<template>
+  <div>
+      <template>
+        <v-data-table
+          :loading="loading"
+          :headers="headers"
+          :items="filteredBots"
+          class="elevation-1"
+        >
+          <template v-slot:body.prepend="{ headers }">
+            <tr>
+              <td></td>
+              <td>
+                <v-select
+                  v-model="filters.state"
+                  :items="states"
+                  clearable
+                  filled
+                  hide-details
+                  dense
+                  class="table-colomns-max"
+                ></v-select>
+              </td>
+              <td></td>
+            </tr>
+          </template>
+          <template slot="no-data">No 3Bot instances available</p></template>
+          <template v-slot:item.domain="{ item }" >
+            <a v-if="deployed3botsStatus[item.state] === 3"  :href="`https://${item.domain}/admin`">{{item.domain}}</a>
+          </template>
+          <template v-slot:item.expiration="{ item }">
+            <div :class="`${item.class}`">{{ item.expiration }}</div>
+          </template>
+          <template v-slot:item.actions="{ item }">
+            <v-tooltip top v-if="deployed3botsStatus[item.state] === 3" >
+              <template v-slot:activator="{ on, attrs }">
+                <v-btn icon :href="`https://${item.domain}/admin`" target="_blank">
+                  <v-icon v-bind="attrs" v-on="on" color="primary">mdi-web</v-icon>
+                </v-btn>
+              </template>
+              <span>Open in browser</span>
+            </v-tooltip>
+            <v-tooltip top  v-if="deployed3botsStatus[item.state] !== 1">
+              <template v-slot:activator="{ on, attrs }">
+
+                <v-btn icon @click.stop="delete3Bot(item)">
+                  <v-icon v-bind="attrs" v-on="on" color="#810000">mdi-delete</v-icon>
+                </v-btn>
+              </template>
+              <span>Destroy</span>
+            </v-tooltip>
+            <v-tooltip top>
+              <template v-slot:activator="{ on, attrs }">
+                <v-btn icon @click.stop="open(item)">
+                  <v-icon v-bind="attrs" v-on="on" color="#206a5d">mdi-information-outline</v-icon>
+                </v-btn>
+              </template>
+              <span>Show Information</span>
+            </v-tooltip>
+            <v-tooltip top v-if="deployed3botsStatus[item.state] == 3">
+              <template v-slot:activator="{ on, attrs }">
+                <v-btn icon @click.stop="stop3Bot(item)">
+                  <v-icon v-bind="attrs" v-on="on" color="#206a5d">mdi-stop-circle</v-icon>
+                </v-btn>
+              </template>
+              <span>Stop</span>
+            </v-tooltip>
+            <v-tooltip top v-if="deployed3botsStatus[item.state] !== 3">
+              <template v-slot:activator="{ on, attrs }">
+                <v-btn icon @click.stop="start3Bot(item)">
+                  <v-icon v-bind="attrs" v-on="on" color="#206a5d">mdi-reload</v-icon>
+                </v-btn>
+              </template>
+              <span>Start</span>
+            </v-tooltip>
+            <v-tooltip top v-if="deployed3botsStatus[item.state] === 2">
+              <template v-slot:activator="{ on, attrs }">
+                <v-btn icon @click.stop="change3BotLocation(item)">
+                  <v-icon v-bind="attrs" v-on="on" color="#206a5d">mdi-map-marker-radius</v-icon>
+                </v-btn>
+              </template>
+              <span>Change location</span>
+            </v-tooltip>
+            <v-tooltip top v-if="deployed3botsStatus[item.state] === 2">
+              <template v-slot:activator="{ on, attrs }">
+                <v-btn icon @click.stop="change3BotSize(item)">
+                  <v-icon v-bind="attrs" v-on="on" color="#206a5d">mdi-arrow-expand-all</v-icon>
+                </v-btn>
+              </template>
+              <span>Change size</span>
+            </v-tooltip>
+
+            <v-tooltip top v-if="item.alert === true">
+              <template v-slot:activator="{ on, attrs }">
+                <v-btn icon>
+                  <v-icon v-bind="attrs" v-on="on" color="#810000">mdi-alert</v-icon>
+                </v-btn>
+              </template>
+              <span>This 3Bot expires in less than 2 days. Please go to your admin dashboard and extend pool {{ item.compute_pool }}</span>
+            </v-tooltip>
+          </template>
+        </v-data-table>
+      </template>
+    <solution-info v-if="selected" v-model="dialogs.info" :data="selected"></solution-info>
+    <cancel-workload v-if="selected" v-model="dialogs.cancelWorkload" :data="selected"></cancel-workload>
+    <stop-workload v-if="selected" v-model="dialogs.stopWorkload" :data="selected"></stop-workload>
+  </div>
+</template>
+
+<script>
+module.exports = {
+  props: ["deployed", "headers", "loading"],
+  components: {
+    "solution-info": httpVueLoader("../solutions/Info.vue"),
+    "cancel-workload": httpVueLoader("../solutions/Delete.vue"),
+    "stop-workload": httpVueLoader("../solutions/Stop.vue"),
+  },
+  data() {
+    return {
+      dialogs: {
+        info: false,
+        cancelWorkload: false,
+        stopWorkload: false,
+        startWorkload: false,
+      },
+      selected: null,
+      deployed3botsStatus: {
+        DELETED: 1,
+        STOPPED: 2,
+        RUNNING: 3,
+      },
+      states:["RUNNING","STOPPED","DELETED"],
+      filters: {
+        state: null,
+      },
+    };
+  },
+  methods: {
+    open(record) {
+      this.selected = record;
+      this.dialogs.info = true;
+    },
+    delete3Bot(record) {
+      this.selected = record;
+      this.dialogs.cancelWorkload = true;
+    },
+    stop3Bot(record) {
+      this.selected = record;
+      this.dialogs.stopWorkload = true;
+    },
+    start3Bot(record) {
+      this.selected = record;
+      this.dialogs.startWorkload = true;
+      this.openChatflow("restart_threebot", this.selected.name);
+    },
+    change3BotSize(record) {
+      this.openChatflow("change_size", record.name);
+    },
+    change3BotLocation(record) {
+      this.openChatflow("change_location", record.name);
+    },
+    openChatflow(type, tname = "") {
+      this.$router.push({
+        name: "SolutionChatflow",
+        params: { topic: type, tname: tname },
+      });
+    },
+  },
+  computed:{
+    filteredBots(){
+      return this.deployed.filter((record) => {
+        let result = [];
+        Object.keys(this.filters).forEach((key) => {
+          result.push(
+            !this.filters[key] ||
+              String(record[key]).includes(this.filters[key])
+          );
+        });
+        return result.every(Boolean);
+      });
+    }
+  }
+};
+</script>
diff --git a/jumpscale/packages/threebot_deployer/frontend/components/solutions/Delete.vue b/jumpscale/packages/threebot_deployer/frontend/components/solutions/Delete.vue
index 70e77b1877..33c31d237b 100644
--- a/jumpscale/packages/threebot_deployer/frontend/components/solutions/Delete.vue
+++ b/jumpscale/packages/threebot_deployer/frontend/components/solutions/Delete.vue
@@ -1,7 +1,7 @@
 <template>
   <base-dialog
     v-if="data"
-    title="Cancel Workload"
+    title="Destroy Workload"
     v-model="dialog"
     :error="error"
     :info="info"
@@ -9,8 +9,10 @@
     :loading="loading"
   >
     <template #default>
-      Are you sure you want to cancel {{data.Name}}?
-      <v-checkbox v-model="deleteBackup" :label="`Delete Backup`" @click="warningShow()"></v-checkbox>
+      Please enter the password of {{ data.name }}. This will stop your running 3Bot and delete all backups.
+      <v-form>
+        <v-text-field :type="'password'" v-model="form.password" dense></v-text-field>
+      </v-form>
     </template>
     <template #actions>
       <v-btn text @click="close">Close</v-btn>
@@ -24,7 +26,6 @@ module.exports = {
   mixins: [dialog],
   data() {
     return {
-      deleteBackup: null,
       lastThreebotSelected: "",
     };
   },
@@ -34,48 +35,21 @@ module.exports = {
       this.loading = true;
       this.error = null;
       this.$api.solutions
-        .cancelReservation(this.data.wids)
+        .destroyThreebot(this.data.solution_uuid, this.form.password)
         .then((response) => {
-          if (this.deleteBackup) {
-            this.$api.solutions
-              .destroyBackup(
-                `${this.data.Owner.split(".")[0]}_${this.data.Name}`
-              )
-              .then((response) => {
-                this.alert("Cancelled 3Bot with delete its backup", "success");
-                this.$router.go(0);
-              })
-              .catch((err) => {
-                this.alert(
-                  "Cancelled 3But but failed to delete backup",
-                  "error"
-                );
-                this.$router.go("Workloads");
-              });
-          } else {
-            this.alert("Cancelled 3Bot", "success");
-            this.$router.go(0);
-          }
+          this.alert("3bot Destroyed", "success");
+          this.$router.go(0);
         })
         .catch((err) => {
-          this.alert("Failed to cancel 3Bot", "error");
+          this.alert("Failed to destroy 3Bot", "error");
           this.close();
         });
     },
-    warningShow() {
-      if (this.deleteBackup) {
-        this.warning =
-          "Warning: If you delete backup, you can't restore your 3Bot again.";
-      } else {
-        this.warning = "";
-      }
-    },
   },
   updated() {
-    if (this.lastThreebotSelected !== this.data.Name) {
-      this.deleteBackup = false;
+    if (this.lastThreebotSelected !== this.data.name) {
       this.warning = "";
-      this.lastThreebotSelected = this.data.Name;
+      this.lastThreebotSelected = this.data.name;
     }
   },
 };
diff --git a/jumpscale/packages/threebot_deployer/frontend/components/solutions/Info.vue b/jumpscale/packages/threebot_deployer/frontend/components/solutions/Info.vue
index f2994e5e73..be4217dd7d 100644
--- a/jumpscale/packages/threebot_deployer/frontend/components/solutions/Info.vue
+++ b/jumpscale/packages/threebot_deployer/frontend/components/solutions/Info.vue
@@ -10,19 +10,64 @@
             <v-simple-table>
               <template v-slot:default>
                 <tbody>
-                  <tr v-for="(item, key)  in json" :key="key">
-                    <th>{{ key }}</th>
-                    <td v-if="KeysWithTypeList.includes(key)" class="pt-2">
-                      <v-chip class="ma-1" v-for="node in item" :key="node">{{ node }}</v-chip>
+                  <tr>
+                    <th>Workload IDs</th>
+                    <td class="pt-2">
+                    <v-chip class="ma-1" v-for="node in json['wids']" :key="node">{{ node }}</v-chip>
                     </td>
-                    <td v-else-if="key === 'nodes'">
-                      <v-chip
-                        class="ma-1"
-                        v-for="(ip, node) in item"
-                        :key="node"
-                      >{{ ip }} / ({{ node }})</v-chip>
-                    </td>
-                    <td v-else>{{ item }}</td>
+                  </tr>
+                  <tr>
+                    <th>3Bot Name</th>
+                    <td> {{ json["name"] }} </td>
+                  </tr>
+                  <tr>
+                    <th>State</th>
+                    <td> {{ json["state"] }} </td>
+                  </tr>
+                  <tr>
+                    <th>Domain</th>
+                    <td v-if="json['state'] === 'RUNNING'"> <a :href="`https://${json['domain']}/admin`" target="_blank"> {{ json["domain"] }} </a> </td>
+                    <td v-else> {{ json["domain"] }} </td>
+                  </tr>
+                  <tr v-if="json['state'] === 'RUNNING'">
+                    <th>IPv4 Address</th>
+                    <td> {{ json["ipv4"] }} </td>
+                  </tr>
+                  <tr>
+                    <th>Network</th>
+                    <td> {{ json["network"] }} </td>
+                  </tr>
+                  <tr v-if="json['state'] === 'RUNNING'">
+                    <th>IPv6 Address</th>
+                    <td> {{ json["ipv6"] }} </td>
+                  </tr>
+                  <tr>
+                    <th>CPU</th>
+                    <td> {{ json["cpu"] }} </td>
+                  </tr>
+                  <tr>
+                    <th>Memory</th>
+                    <td> {{ json["memory"] }} </td>
+                  </tr>
+                  <tr>
+                    <th>Disk Size</th>
+                    <td> {{ json["disk_size"] }} </td>
+                  </tr>
+                  <tr>
+                    <th>Farm</th>
+                    <td> {{ json["farm"] }} </td>
+                  </tr>
+                  <tr>
+                    <th>Continent</th>
+                    <td> {{ json["continent"] }} </td>
+                  </tr>
+                  <tr>
+                    <th>Node ID</th>
+                    <td> {{ json["node"] }} </td>
+                  </tr>
+                  <tr v-if="json['state'] === 'RUNNING'">
+                    <th>Expiration</th>
+                    <td> {{ json["expiration"] }} </td>
                   </tr>
                 </tbody>
               </template>
diff --git a/jumpscale/packages/threebot_deployer/frontend/components/solutions/SolutionChatflow.vue b/jumpscale/packages/threebot_deployer/frontend/components/solutions/SolutionChatflow.vue
index 475e224f0b..21d5973c39 100644
--- a/jumpscale/packages/threebot_deployer/frontend/components/solutions/SolutionChatflow.vue
+++ b/jumpscale/packages/threebot_deployer/frontend/components/solutions/SolutionChatflow.vue
@@ -3,28 +3,40 @@
 </template>
 
 <script>
-  module.exports = {
-    props: {topic: String},
-    computed: {
-      url () {
-        return `/threebot_deployer/chats/${this.topic}?noheader=yes`
-      }
+module.exports = {
+  props: {
+    topic: String,
+    tname: {
+      type: String,
+      default: "",
     },
-    mounted() {
-
-      if(window.threebot_deployer_chatflow_end_listener_set === undefined) { // avoid setting multiple listeners
-        window.threebot_deployer_chatflow_end_listener_set = true
-        window.addEventListener("message", event => {
-
-          let message = "chat ended: "
-          let len = message.length
-          if(event.origin != location.origin || event.data.slice(0, len) != message)
-            return;
-          this.$router.push({
-            name: "Workloads",
-          })
-        })
+  },
+  computed: {
+    url() {
+      if (this.tname != "") {
+        return `/threebot_deployer/chats/${this.topic}#/?noheader=yes&tname=${this.tname}`;
+      } else {
+        return `/threebot_deployer/chats/${this.topic}#/?noheader=yes`;
       }
+    },
+  },
+  mounted() {
+    if (window.threebot_deployer_chatflow_end_listener_set === undefined) {
+      // avoid setting multiple listeners
+      window.threebot_deployer_chatflow_end_listener_set = true;
+      window.addEventListener("message", (event) => {
+        let message = "chat ended: ";
+        let len = message.length;
+        if (
+          event.origin != location.origin ||
+          event.data.slice(0, len) != message
+        )
+          return;
+        this.$router.push({
+          name: "Workloads",
+        });
+      });
     }
-  }
+  },
+};
 </script>
diff --git a/jumpscale/packages/threebot_deployer/frontend/components/solutions/Stop.vue b/jumpscale/packages/threebot_deployer/frontend/components/solutions/Stop.vue
new file mode 100644
index 0000000000..fb0910821b
--- /dev/null
+++ b/jumpscale/packages/threebot_deployer/frontend/components/solutions/Stop.vue
@@ -0,0 +1,56 @@
+<template>
+  <base-dialog
+    v-if="data"
+    title="Stop Workload"
+    v-model="dialog"
+    :error="error"
+    :info="info"
+    :warning="warning"
+    :loading="loading"
+  >
+    <template #default>
+      Please enter the password of {{ data.name }}. This will stop your running 3Bot.
+      <v-form>
+        <v-text-field :type="'password'" v-model="form.password" dense></v-text-field>
+      </v-form>
+    </template>
+    <template #actions>
+      <v-btn text @click="close">Close</v-btn>
+      <v-btn text color="error" @click="submit">Confirm</v-btn>
+    </template>
+  </base-dialog>
+</template>
+
+<script>
+module.exports = {
+  mixins: [dialog],
+  data() {
+    return {
+      lastThreebotSelected: "",
+    };
+  },
+  props: { data: Object },
+  methods: {
+    submit() {
+      this.loading = true;
+      this.error = null;
+      this.$api.solutions
+        .stopThreebot(this.data.solution_uuid, this.form.password)
+        .then((response) => {
+          this.alert("Stopped 3Bot", "success");
+          this.$router.go(0);
+        })
+        .catch((err) => {
+          this.alert("Failed to Stop 3Bot", "error");
+          this.close();
+        });
+    },
+  },
+  updated() {
+    if (this.lastThreebotSelected !== this.data.name) {
+      this.warning = "";
+      this.lastThreebotSelected = this.data.name;
+    }
+  },
+};
+</script>
diff --git a/jumpscale/packages/threebot_deployer/frontend/components/solutions/Workloads.vue b/jumpscale/packages/threebot_deployer/frontend/components/solutions/Workloads.vue
index ddb7ffab8f..e06f6eaebf 100644
--- a/jumpscale/packages/threebot_deployer/frontend/components/solutions/Workloads.vue
+++ b/jumpscale/packages/threebot_deployer/frontend/components/solutions/Workloads.vue
@@ -1,101 +1,65 @@
 <template>
   <div>
-    <base-component title="MY 3BOTS" icon="mdi-clipboard-list-outline" :loading="loading">
+    <base-component
+      title="MY 3BOTS"
+      icon="mdi-clipboard-list-outline"
+      :loading="loading"
+    >
       <template #actions>
-        <v-btn color="primary" text @click.stop="openChatflow('extend')">
-          <v-icon left>mdi-upload</v-icon>Extend 3Bot
-        </v-btn>
         <v-btn color="primary" text @click.stop="openChatflow('threebot')">
           <v-icon left>mdi-plus</v-icon>New
         </v-btn>
       </template>
-
-      <template #default>
-        <v-data-table
-          :loading="loading"
-          :headers="headers"
-          :items="deployed3Bots"
-          class="elevation-1"
-        >
-          <template slot="no-data">No 3Bot instances available</p></template>
-          <template v-slot:item.domain="{ item }">
-            <a :href="`https://${item.Domain}/admin`">{{item.Domain}}</a>
-          </template>
-          <template v-slot:item.Expiration="{ item }">
-            <div :class="`${item.class}`">{{ item.Expiration }}</div>
-          </template>
-          <template v-slot:item.actions="{ item }">
-            <v-tooltip top>
-              <template v-slot:activator="{ on, attrs }">
-                <v-btn icon :href="`https://${item.Domain}/admin`">
-                  <v-icon v-bind="attrs" v-on="on" color="primary">mdi-web</v-icon>
-                </v-btn>
-              </template>
-              <span>Open in browser</span>
-            </v-tooltip>
-            <v-tooltip top>
-              <template v-slot:activator="{ on, attrs }">
-                <v-btn icon @click.stop="delete3Bot(item)">
-                  <v-icon v-bind="attrs" v-on="on" color="#810000">mdi-delete</v-icon>
-                </v-btn>
-              </template>
-              <span>Delete</span>
-            </v-tooltip>
-            <v-tooltip top>
-              <template v-slot:activator="{ on, attrs }">
-                <v-btn icon @click.stop="open(item)">
-                  <v-icon v-bind="attrs" v-on="on" color="#206a5d">mdi-information-outline</v-icon>
-                </v-btn>
-              </template>
-              <span>Show Information</span>
-            </v-tooltip>
-          </template>
-        </v-data-table>
-      </template>
+      <div class="mt-5">
+        <template>
+          <deployer-data-table
+            :deployed="deployed3Bots"
+            :headers="headers3Bots"
+            :loading="loading"
+          >
+          </deployer-data-table>
+        </template>
+      </div>
     </base-component>
-    <solution-info v-if="selected" v-model="dialogs.info" :data="selected"></solution-info>
-    <cancel-workload v-if="selected" v-model="dialogs.cancelWorkload" :data="selected"></cancel-workload>
   </div>
 </template>
 
 <script>
 module.exports = {
   components: {
-    "solution-info": httpVueLoader("./Info.vue"),
-    "cancel-workload": httpVueLoader("./Delete.vue"),
+    "deployer-data-table": httpVueLoader("../base/Table.vue"),
   },
   data() {
     return {
       threebot_data: APPS["threebot"],
-      dialogs: {
-        info: false,
-        cancelWorkload: false,
-      },
-      selected: null,
       loading: true,
-      headers: [
-        { text: "Name", value: "Name" },
-        { text: "URL", value: "domain" },
-        { text: "Expiration", value: "expiration" },
+      headers3Bots: [
+        { text: "Name", value: "name" },
+        { text: "State", value: "state"},
         { text: "Actions", value: "actions", sortable: false },
       ],
       deployed3Bots: [],
     };
   },
   methods: {
-    open(record) {
-      this.selected = record;
-      this.dialogs.info = true;
-    },
-    delete3Bot(record) {
-      this.selected = record;
-      this.dialogs.cancelWorkload = true;
-    },
-    openChatflow(type) {
+    openChatflow(type, tname = "") {
       this.$router.push({
         name: "SolutionChatflow",
-        params: { topic: type },
+        params: { topic: type, tname: tname },
+      });
+    },
+    groupBy(list, keyGetter) {
+      const map = new Map();
+      list.forEach((item) => {
+        const key = keyGetter(item);
+        const collection = map.get(key);
+        if (!collection) {
+          map.set(key, [item]);
+        } else {
+          collection.push(item);
+        }
       });
+      return map;
     },
     getDeployedSolutions() {
       const DURATION_MAX = 9223372036854775807;
@@ -103,27 +67,24 @@ module.exports = {
       let alert_time = new Date();
       alert_time.setDate(today.getDate() + 2);
       this.$api.solutions
-        .getDeployed()
+        .getAllThreebots()
         .then((response) => {
           this.deployed3Bots = [...response.data.data];
           for (let i = 0; i < this.deployed3Bots.length; i++) {
             deployed3Bot = this.deployed3Bots[i];
-            if (deployed3Bot.Expiration < DURATION_MAX) {
-              let expiration = new Date(deployed3Bot.Expiration * 1000);
-              deployed3Bot.Expiration = expiration.toLocaleString('en-GB');
-              if (expiration < today) {
-                deployed3Bot.class = "red--text";
-                deployed3Bot.Expiration = "EXPIRED";
-              } else if (expiration < alert_time) {
-                deployed3Bot.class = "red--text";
-              } else {
-                deployed3Bot.class = "";
+            deployed3Bot.alert = false;
+            if (deployed3Bot.expiration < DURATION_MAX) {
+              let expiration = new Date(deployed3Bot.expiration * 1000);
+              deployed3Bot.expiration = expiration.toLocaleString("en-GB");
+              if (expiration < alert_time) {
+                deployed3Bot.alert = true;
               }
             } else {
-              deployed3Bot.Expiration = "-";
+              deployed3Bot.expiration = "-";
             }
           }
-        }).finally(() => {
+        })
+        .finally(() => {
           this.loading = false;
         });
     },
diff --git a/jumpscale/packages/threebot_deployer/frontend/index.js b/jumpscale/packages/threebot_deployer/frontend/index.js
index afa9f44735..040d50864a 100644
--- a/jumpscale/packages/threebot_deployer/frontend/index.js
+++ b/jumpscale/packages/threebot_deployer/frontend/index.js
@@ -58,7 +58,7 @@ const router = new VueRouter({
     { name: "License", path: '/license', component: license, meta: { icon: "mdi-apps" } },
     { name: "Terms", path: '/terms', component: terms, meta: { icon: "mdi-apps" } },
     { name: "Disclaimer", path: '/disclaimer', component: disclaimer, meta: { icon: "mdi-apps" } },
-    { name: "SolutionChatflow", path: '/chats/:topic', component: solutionChatflow, props: true, meta: { icon: "mdi-tune" } },
+    { name: "SolutionChatflow", path: '/chats/:topic/:tname', component: solutionChatflow, props: true, meta: { icon: "mdi-tune" } },
     { name: "Workloads", path: '/workloads', component: workloads, meta: { icon: "mdi-tune" } },
   ]
 })
diff --git a/jumpscale/packages/threebot_deployer/frontend/style.css b/jumpscale/packages/threebot_deployer/frontend/style.css
index ee3dcb858e..ef66134a11 100644
--- a/jumpscale/packages/threebot_deployer/frontend/style.css
+++ b/jumpscale/packages/threebot_deployer/frontend/style.css
@@ -7,3 +7,7 @@
 .theme--light.v-tabs-items {
     background-color: #FBFCFC !important;
 }
+
+.table-colomns-max{
+    max-width: 200px;
+}
diff --git a/jumpscale/packages/threebot_deployer/models/__init__.py b/jumpscale/packages/threebot_deployer/models/__init__.py
new file mode 100644
index 0000000000..724cf58f37
--- /dev/null
+++ b/jumpscale/packages/threebot_deployer/models/__init__.py
@@ -0,0 +1,9 @@
+from jumpscale.core.base import StoredFactory
+from .backup_tokens import BackupTokens
+from .user_solutions import UserThreebot
+
+BACKUP_MODEL_FACTORY = StoredFactory(BackupTokens)
+BACKUP_MODEL_FACTORY.always_reload = True
+
+USER_THREEBOT_FACTORY = StoredFactory(UserThreebot)
+USER_THREEBOT_FACTORY.always_reload = True
diff --git a/jumpscale/packages/threebot_deployer/models/backup_tokens.py b/jumpscale/packages/threebot_deployer/models/backup_tokens.py
index 5cca42153e..4cc491a284 100644
--- a/jumpscale/packages/threebot_deployer/models/backup_tokens.py
+++ b/jumpscale/packages/threebot_deployer/models/backup_tokens.py
@@ -1,5 +1,4 @@
 from jumpscale.core.base import Base, fields
-from jumpscale.loader import j
 
 
 class BackupTokens(Base):
diff --git a/jumpscale/packages/threebot_deployer/models/backup_tokens_sal.py b/jumpscale/packages/threebot_deployer/models/backup_tokens_sal.py
deleted file mode 100644
index 5519d4a457..0000000000
--- a/jumpscale/packages/threebot_deployer/models/backup_tokens_sal.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from jumpscale.core.base import StoredFactory
-from jumpscale.packages.threebot_deployer.models.backup_tokens import BackupTokens
-
-BACKUP_MODEL_FACTORY = StoredFactory(BackupTokens)
-BACKUP_MODEL_FACTORY.always_reload = True
diff --git a/jumpscale/packages/threebot_deployer/models/user_solutions.py b/jumpscale/packages/threebot_deployer/models/user_solutions.py
new file mode 100644
index 0000000000..86b207c6a6
--- /dev/null
+++ b/jumpscale/packages/threebot_deployer/models/user_solutions.py
@@ -0,0 +1,24 @@
+from jumpscale.core.base import Base, fields
+from enum import Enum
+
+
+class ThreebotState(Enum):
+    RUNNING = "RUNNING"  # the workloads are deployed and running
+    DELETED = "DELETED"  # workloads and backups deleted
+    STOPPED = "STOPPED"  # expired or manually stoped (delete workloads only)
+
+
+class UserThreebot(Base):
+    # instance name is the f"threebot_{solution uuid}"
+    solution_uuid = fields.String()
+    identity_tid = fields.Integer()
+    name = fields.String()
+    owner_tname = fields.String()  # owner's tname in 3bot connect after cleaning
+    farm_name = fields.String()
+    state = fields.Enum(ThreebotState)
+    continent = fields.String()
+    explorer_url = fields.String()
+    threebot_container_wid = fields.Integer()
+    trc_container_wid = fields.Integer()
+    reverse_proxy_wid = fields.Integer()
+    subdomain_wid = fields.Integer()
diff --git a/jumpscale/packages/threebot_deployer/scripts/backup.sh b/jumpscale/packages/threebot_deployer/scripts/backup.sh
index 9d1fb802c8..a0641c7032 100644
--- a/jumpscale/packages/threebot_deployer/scripts/backup.sh
+++ b/jumpscale/packages/threebot_deployer/scripts/backup.sh
@@ -7,8 +7,8 @@ gzip -d rest-server-0.9.7-linux-amd64.gz
 chmod +x rest-server-0.9.7-linux-amd64
 mv /root/rest-server-0.9.7-linux-amd64 /usr/bin/rest-server
 
-apt-get install  -y apache2
+apt-get install -y apache2
 /etc/init.d/apache2 restart
-mkdir /root/backup_config /root/backup
+mkdir /root/backup
 touch /root/backup/.htpasswd
-rest-server --private-repos --path /root/backup_config
+rest-server --private-repos --path /root/backup
diff --git a/jumpscale/sals/marketplace/apps_chatflow.py b/jumpscale/sals/marketplace/apps_chatflow.py
index 55fe51c790..f0b02db79b 100644
--- a/jumpscale/sals/marketplace/apps_chatflow.py
+++ b/jumpscale/sals/marketplace/apps_chatflow.py
@@ -16,18 +16,9 @@
 from .solutions import solutions
 from jumpscale.clients.explorer.models import WorkloadType
 
-FLAVORS = {
-    "Silver": {"sru": 2,},
-    "Gold": {"sru": 5,},
-    "Platinum": {"sru": 10,},
-}
+FLAVORS = {"Silver": {"sru": 2}, "Gold": {"sru": 5}, "Platinum": {"sru": 10}}
 
-RESOURCE_VALUE_KEYS = {
-    "cru": "CPU {}",
-    "mru": "Memory {} GB",
-    "sru": "Disk {} GB [SSD]",
-    "hru": "Disk {} GB [HDD]",
-}
+RESOURCE_VALUE_KEYS = {"cru": "CPU {}", "mru": "Memory {} GB", "sru": "Disk {} GB [SSD]", "hru": "Disk {} GB [HDD]"}
 
 
 class MarketPlaceAppsChatflow(MarketPlaceChatflow):
@@ -47,6 +38,8 @@ def _init_solution(self):
         self.retries = 3
         self.custom_domain = False
         self.allow_custom_domain = False
+        self.currency = "TFT"
+        self.identity_name = j.core.identity.me.instance_name
 
     def _choose_flavor(self, flavors=None):
         flavors = flavors or FLAVORS
@@ -72,39 +65,34 @@ def _choose_flavor(self, flavors=None):
         self.flavor = chosen_flavor.split()[0]
         self.flavor_resources = flavors[self.flavor]
 
-    def _get_pool(self):
-        self.currency = "TFT"
-        farm_names = [f.name for f in j.sals.zos.get()._explorer.farms.list()]
-        random.shuffle(farm_names)
-        # farm_names = ["freefarm"]  # DEUBGGING ONLY
-        self.farm_name = None
-
-        for farm_name in farm_names:
-            available_ipv4, _, _, _, _ = deployer.check_farm_capacity(
-                farm_name, currencies=[self.currency], ip_version="IPv4"
-            )
-            available_ipv6, _, _, _, _ = deployer.check_farm_capacity(
-                farm_name, currencies=[self.currency], ip_version="IPv6", **self.query
-            )
-            if available_ipv4 and available_ipv6:
-                self.farm_name = farm_name
-                break
+    def _select_farms(self):
+        self.farm_name = random.choice(self.available_farms).name
+        self.pool_farm_name = None
 
-        if not self.farm_name:
-            raise StopChatFlow("Failed to find farm with the requested resources")
+    def _select_pool_node(self):
+        """Children should override this if they want to force the pool to contain a specific node id"""
+        self.pool_node_id = None
 
+    def _get_pool(self):
+        self._get_available_farms(only_one=True)
+        self._select_farms()
+        self._select_pool_node()
         user_networks = solutions.list_network_solutions(self.solution_metadata["owner"])
         networks_names = [n["Name"] for n in user_networks]
         if "apps" in networks_names:
             # old user
             self.md_show_update("Checking for free resources .....")
-            free_pools = deployer.get_free_pools(self.solution_metadata["owner"], **self.query)
+            free_pools = deployer.get_free_pools(
+                self.solution_metadata["owner"], farm_name=self.pool_farm_name, node_id=self.pool_node_id, **self.query
+            )
             if free_pools:
                 self.md_show_update(
                     "Searching for a best fit pool (best fit pool would try to find a pool that matches your resources or with least difference from the required specs)..."
                 )
                 # select free pool and extend if required
-                pool, cu_diff, su_diff = deployer.get_best_fit_pool(free_pools, self.expiration, **self.query)
+                pool, cu_diff, su_diff = deployer.get_best_fit_pool(
+                    free_pools, self.expiration, farm_name=self.pool_farm_name, node_id=self.pool_node_id, **self.query
+                )
                 if cu_diff < 0 or su_diff < 0:
                     cu_diff = abs(cu_diff) if cu_diff < 0 else 0
                     su_diff = abs(su_diff) if su_diff < 0 else 0
@@ -152,12 +140,7 @@ def _get_pool(self):
                 currency=self.currency,
                 **self.query,
             )
-            if not all(
-                [
-                    self.pool_info.escrow_information.address.strip() != "",
-                    self.pool_info.escrow_information.address.strip() != "",
-                ]
-            ):
+            if self.pool_info.escrow_information.address.strip() == "":
                 raise StopChatFlow(
                     f"provisioning the pool, invalid escrow information probably caused by a misconfigured, pool creation request was {self.pool_info}"
                 )
@@ -170,8 +153,14 @@ def _get_pool(self):
             )
             self.pool_id = self.pool_info.reservation_id
 
+        self.network_view = deployer.get_network_view(
+            f"{self.solution_metadata['owner']}_apps", identity_name=self.identity_name
+        )
         return self.pool_id
 
+    def _select_node(self):
+        self.selected_node = deployer.schedule_container(self.pool_id, ip_version=self.ip_version, **self.query)
+
     @chatflow_step(title="New Expiration")
     def set_expiration(self):
         self.expiration = deployer.ask_expiration(self)
@@ -180,7 +169,7 @@ def set_expiration(self):
     def upload_public_key(self):
         self.public_key = (
             self.upload_file(
-                "Please upload your public ssh key, this will allow you to access your threebot container using ssh",
+                "Please upload your public ssh key, this will allow you to access your threebot container using ssh"
             )
             or ""
         )
@@ -205,16 +194,16 @@ def backup_credentials(self):
     @deployment_context()
     def _deploy_network(self):
         # get ip address
-        self.network_view = deployer.get_network_view(f"{self.solution_metadata['owner']}_apps")
         self.ip_address = None
         while not self.ip_address:
-            self.selected_node = deployer.schedule_container(self.pool_id, ip_version=self.ip_version, **self.query)
+            self._select_node()
             result = deployer.add_network_node(
                 self.network_view.name,
                 self.selected_node,
                 self.pool_id,
                 self.network_view,
                 bot=self,
+                identity_name=self.identity_name,
                 owner=self.solution_metadata.get("owner"),
             )
             if result:
@@ -298,7 +287,7 @@ def wait_domain(self, domain, ip_addresses=None, timeout=10):
     def _get_domain(self):
         # get domain for the ip address
         self.md_show_update("Preparing gateways ...")
-        gateways = deployer.list_all_gateways(self.username, self.farm_name)
+        gateways = deployer.list_all_gateways(self.username, self.farm_name, identity_name=self.identity_name)
         if not gateways:
             raise StopChatFlow(
                 "There are no available gateways in the farms bound to your pools. The resources you paid for will be re-used in your upcoming deployments."
@@ -318,7 +307,9 @@ def _get_domain(self):
                 is_managed_domains = True
                 if domain in blocked_domains:
                     continue
-                success = deployer.test_managed_domain(gateway.node_id, domain, gw_dict["pool"].pool_id, gateway)
+                success = deployer.test_managed_domain(
+                    gateway.node_id, domain, gw_dict["pool"].pool_id, gateway, identity_name=self.identity_name
+                )
                 if not success:
                     j.logger.warning(f"managed domain {domain} failed to populate subdomain. skipping")
                     deployer.block_managed_domain(domain)
@@ -426,6 +417,34 @@ def get_solution_name(self):
                 valid = True
         self.solution_name = f"{self.solution_metadata['owner']}-{self.solution_name}"
 
+    def _get_available_farms(self, only_one=True, identity_name=None):
+        if getattr(self, "available_farms", None) is not None:
+            return
+        self.currency = getattr(self, "currency", "TFT")
+        farm_message = f"""\
+        Fetching available farms..
+        """
+        self.md_show_update(dedent(farm_message))
+
+        self.available_farms = []
+        farms = j.sals.zos.get(identity_name)._explorer.farms.list()
+        # farm_names = ["freefarm"]  # DEUBGGING ONLY
+
+        for farm in farms:
+            farm_name = farm.name
+            available_ipv4, _, _, _, _ = deployer.check_farm_capacity(
+                farm_name, currencies=[self.currency], ip_version="IPv4"
+            )
+            available_ipv6, _, _, _, _ = deployer.check_farm_capacity(
+                farm_name, currencies=[self.currency], ip_version="IPv6", **self.query
+            )
+            if available_ipv4 and available_ipv6:
+                self.available_farms.append(farm)
+                if only_one:
+                    return
+        if not self.available_farms:
+            raise StopChatFlow("No available farms with enough resources for this deployment at the moment")
+
     @chatflow_step(title="Setup", disable_previous=True)
     def infrastructure_setup(self):
         self.md_show_update("Preparing Infrastructure...")
@@ -495,6 +514,7 @@ def new_expiration(self):
 
     @chatflow_step(title="Payment")
     def solution_extension(self):
+        self.md_show_update("Extending pool...")
         self.currencies = ["TFT"]
         self.pool_info, self.qr_code = deployer.extend_solution_pool(
             self, self.pool_id, self.expiration, self.currencies, **self.query
@@ -507,7 +527,8 @@ def solution_extension(self):
 
     @chatflow_step(title="Reservation", disable_previous=True)
     def reservation(self):
-        self.secret = f"{j.core.identity.me.tid}:{uuid.uuid4().hex}"
+        identity_tid = j.core.identity.get(self.identity_name).tid
+        self.secret = f"{identity_tid}:{uuid.uuid4().hex}"
         success = False
         while not success:
             try:
diff --git a/jumpscale/sals/marketplace/deployer.py b/jumpscale/sals/marketplace/deployer.py
index dd55a9f60f..1bb021241c 100644
--- a/jumpscale/sals/marketplace/deployer.py
+++ b/jumpscale/sals/marketplace/deployer.py
@@ -20,35 +20,33 @@ class MarketPlaceDeployer(ChatflowDeployer):
 
     WALLET_NAME = "demos_wallet"
 
-    def list_user_pool_ids(self, username):
+    def list_user_pool_ids(self, username, identity_name=None):
+        identity_name = identity_name or j.core.identity.me.instance_name
+        identity = j.core.identity.get(identity_name)
         user_pools = self.list_user_pools(username)
-        user_pool_ids = [p.pool_id for p in user_pools]
+        user_pool_ids = [p.pool_id for p in user_pools if p.customer_tid == identity.tid]
         return user_pool_ids
 
-    def list_user_pools(self, username):
+    def list_user_pools(self, username, identity_name=None):
         _, _, user_pools = pool_factory.find_many(owner=username)
-        all_pools = [p for p in j.sals.zos.get().pools.list() if p.node_ids]
+        all_pools = [p for p in j.sals.zos.get(identity_name).pools.list() if p.node_ids]
         user_pool_ids = [p.pool_id for p in user_pools]
         result = [p for p in all_pools if p.pool_id in user_pool_ids]
         return result
 
-    def list_networks(self, username, next_action=NextAction.DEPLOY, sync=True):
-        if sync:
-            self.load_user_workloads(next_action=next_action)
-        networks = {}  # name: last child network resource
-        for pool_id in self.workloads[next_action][WorkloadType.Network_resource]:
-            for workload in self.workloads[next_action][WorkloadType.Network_resource][pool_id]:
-                metadata = j.data.serializers.json.loads(workload.info.metadata)
-                if metadata.get("owner") == username:
-                    networks[workload.name] = workload
-        all_workloads = []
-        workload_values = self.workloads[next_action].values()
-        for pools_workloads in workload_values:
-            for pool_id, workload_list in pools_workloads.items():
-                for workload in workload_list:
-                    metadata = j.data.serializers.json.loads(workload.info.metadata)
-                    if metadata.get("owner") == username:
-                        all_workloads.append(workload)
+    def list_networks(self, username, next_action=NextAction.DEPLOY, identity_name=None):
+        identity_name = identity_name or j.core.identity.me.instance_name
+        identity = j.core.identity.get(identity_name)
+        zos = j.sals.zos.get(identity_name)
+        all_workloads = zos.workloads.list(identity.tid, next_action)
+        networks = set()
+        for workload in all_workloads:
+            decrypted_metadata = j.sals.reservation_chatflow.deployer.decrypt_metadata(
+                workload.info.metadata, identity_name
+            )
+            metadata = j.data.serializers.json.loads(decrypted_metadata)
+            if metadata.get("owner") == username and workload.info.workload_type == WorkloadType.Network_resource:
+                networks.add(workload.name)
         network_views = {}
         if all_workloads:
             for network_name in networks:
@@ -129,22 +127,24 @@ def select_network(self, username, bot):
         network_name = bot.single_choice("Please select a network", network_names, required=True)
         return network_views[f"{username}_{network_name}"]
 
-    def _check_pool_factory_owner(self, instance_name):
+    def _check_pool_factory_owner(self, instance_name, identity_name=None):
+        identity_name = identity_name or j.core.identity.me.instance_name
         pool_instance = pool_factory.get(instance_name)
         pool_id = pool_instance.pool_id
         pool_tid = j.sals.zos.get().pools.get(pool_id).customer_tid
         pool_explorer_url = pool_instance.explorer_url
-        me = j.core.identity.me
+        me = j.core.identity.get(identity_name)
         try:
             return pool_tid == me.tid and pool_explorer_url == me.explorer_url
         except HTTPError:
             return False
 
-    def _get_gateways_pools(self, farm_name):
+    def _get_gateways_pools(self, farm_name, identity_name=None):
         """
         Returns:
             List : will return pool ids for pools on farms with gateways
         """
+        identity_name = identity_name or j.core.identity.me.instance_name
         gateways_pools_ids = []
         farms_ids_with_gateways = [
             gateway_farm.farm_id for gateway_farm in deployer._explorer.gateway.list() if gateway_farm.farm_id > 0
@@ -155,19 +155,22 @@ def _get_gateways_pools(self, farm_name):
 
         for farm_name in farms_names_with_gateways:
             gw_pool_name = f"marketplace_gateway_{farm_name}"
-            if gw_pool_name not in pool_factory.list_all() or not self._check_pool_factory_owner(gw_pool_name):
-                gateways_pool_info = deployer.create_gateway_emptypool(gw_pool_name, farm_name)
+            if gw_pool_name not in pool_factory.list_all() or not self._check_pool_factory_owner(
+                gw_pool_name, identity_name
+            ):
+                gateways_pool_info = deployer.create_gateway_emptypool(gw_pool_name, farm_name, identity_name)
                 gateways_pools_ids.append(gateways_pool_info.reservation_id)
             else:
                 pool_id = pool_factory.get(gw_pool_name).pool_id
                 gateways_pools_ids.append(pool_id)
         return gateways_pools_ids
 
-    def list_all_gateways(self, username, farm_name=None):
-        pool_ids = self.list_user_pool_ids(username)
-        gateways_pools = self._get_gateways_pools(farm_name)  # Empty pools contains the gateways only
+    def list_all_gateways(self, username, farm_name=None, identity_name=None):
+        identity_name = identity_name or j.core.identity.me.instance_name
+        pool_ids = self.list_user_pool_ids(username, identity_name)
+        gateways_pools = self._get_gateways_pools(farm_name, identity_name)  # Empty pools contains the gateways only
         pool_ids.extend(gateways_pools)
-        return super().list_all_gateways(pool_ids=pool_ids)
+        return super().list_all_gateways(pool_ids=pool_ids, identity_name=identity_name)
 
     def select_gateway(self, username, bot):
         """
@@ -316,8 +319,16 @@ def create_solution_pool(self, bot, username, farm_name, expiration, currency, *
         user_pool.save()
         return pool_info
 
-    def create_gateway_emptypool(self, gwpool_name, farm_name):
-        pool_info = j.sals.zos.get().pools.create(0, 0, farm_name, ["TFT"])
+    def create_3bot_pool(self, farm_name, expiration, currency, identity_name, **resources):
+        cu, su = self.calculate_capacity_units(**resources)
+        pool_info = j.sals.zos.get(identity_name).pools.create(
+            int(cu * expiration), int(su * expiration), farm_name, [currency]
+        )
+        return pool_info
+
+    def create_gateway_emptypool(self, gwpool_name, farm_name, identity_name=None):
+        identity_name = identity_name or j.core.identity.me.instance_name
+        pool_info = j.sals.zos.get(identity_name).pools.create(0, 0, farm_name, ["TFT"])
         user_pool = pool_factory.get(gwpool_name)
         user_pool.owner = gwpool_name
         user_pool.pool_id = pool_info.reservation_id
@@ -326,7 +337,17 @@ def create_gateway_emptypool(self, gwpool_name, farm_name):
         return pool_info
 
     def get_free_pools(
-        self, username, workload_types=None, free_to_use=False, cru=0, mru=0, sru=0, hru=0, ip_version="IPv6"
+        self,
+        username,
+        workload_types=None,
+        free_to_use=False,
+        cru=0,
+        mru=0,
+        sru=0,
+        hru=0,
+        ip_version="IPv6",
+        farm_name=None,
+        node_id=None,
     ):
         def is_pool_free(pool, nodes_dict):
             for node_id in pool.node_ids:
@@ -343,6 +364,10 @@ def is_pool_free(pool, nodes_dict):
         if free_to_use:
             nodes = {node.node_id: node for node in j.sals.zos.get()._explorer.nodes.list()}
         for pool in user_pools:
+            if farm_name and self.get_pool_farm_name(pool.pool_id) != farm_name:
+                continue
+            if node_id and node_id not in pool.node_ids:
+                continue
             valid = True
             try:
                 j.sals.reservation_chatflow.reservation_chatflow.get_nodes(
@@ -368,8 +393,14 @@ def is_pool_free(pool, nodes_dict):
             free_pools.append(pool)
         return free_pools
 
-    def get_best_fit_pool(self, pools, expiration, cru=0, mru=0, sru=0, hru=0):
+    def get_farm_name(self, farm_id):
+        return j.sals.zos.get()._explorer.farms.get(farm_id).name
+
+    def get_pool_farm_name(self, pool_id=None, pool=None):
+        pool_id = pool_id or pool.pool_id
+        return self.get_farm_name(self.get_pool_farm_id(pool_id=pool_id))
 
+    def get_best_fit_pool(self, pools, expiration, cru=0, mru=0, sru=0, hru=0, farm_name=None, node_id=None):
         cu, su = self.calculate_capacity_units(cru, mru, sru, hru)
         required_cu = cu * expiration
         required_su = su * expiration
@@ -377,6 +408,12 @@ def get_best_fit_pool(self, pools, expiration, cru=0, mru=0, sru=0, hru=0):
         over_fit_pools = []  # contains pools that have higher cus AND sus than the required resources
         under_fit_pools = []  # contains pools that have lower cus OR sus than the required resources
         for pool in pools:
+            if farm_name and self.get_pool_farm_name(pool.pool_id) != farm_name:
+                continue
+
+            if node_id and node_id not in pool.node_ids:
+                continue
+
             if pool.cus == required_cu and pool.sus == required_su:
                 exact_fit_pools.append(pool)
             else:
@@ -402,17 +439,19 @@ def get_best_fit_pool(self, pools, expiration, cru=0, mru=0, sru=0, hru=0):
             result_pool = sorted_result[0]
             return result_pool, result_pool.cus - required_cu, result_pool.sus - required_su
 
-    def init_new_user_network(self, bot, username, pool_id, ip_version="IPv4"):
+    def init_new_user_network(self, bot, username, pool_id, ip_version="IPv4", identity_name=None, network_name=None):
+        network_name = network_name or f"{username}_apps"
         access_node = j.sals.reservation_chatflow.reservation_chatflow.get_nodes(
             1, pool_ids=[pool_id], ip_version=ip_version
         )[0]
-
+        identity_name = identity_name or j.core.identity.me.instance_name
         result = self.deploy_network(
-            name=f"{username}_apps",
+            name=network_name,
             access_node=access_node,
             ip_range="10.100.0.0/16",
             ip_version="IPv4",
             pool_id=pool_id,
+            identity_name=identity_name,
             owner=username,
         )
         for wid in result["ids"]:
@@ -420,11 +459,11 @@ def init_new_user_network(self, bot, username, pool_id, ip_version="IPv4"):
                 success = self.wait_workload(wid, bot=bot)
             except StopChatFlow as e:
                 for sol_wid in result["ids"]:
-                    j.sals.zos.get().workloads.decomission(sol_wid)
+                    j.sals.zos.get(identity_name).workloads.decomission(sol_wid)
                 raise e
             if not success:
                 for sol_wid in result["ids"]:
-                    j.sals.zos.get().workloads.decomission(sol_wid)
+                    j.sals.zos.get(identity_name).workloads.decomission(sol_wid)
                 raise DeploymentFailed(
                     f"Failed to deploy apps network in workload {wid}. The resources you paid for will be re-used in your upcoming deployments.",
                     wid=wid,
@@ -456,5 +495,31 @@ def ask_expiration(self, bot, default=None, msg="", min=None, pool_empty_at=None
         current_pool_expiration = pool_empty_at or j.data.time.utcnow().timestamp
         return self.expiration - current_pool_expiration
 
+    def group_farms_by_continent(self, farms):
+        location_dict = {}
+        for farm in farms:
+            if farm.location.continent:
+                if farm.location.continent not in location_dict:
+                    location_dict[farm.location.continent] = []
+                location_dict[farm.location.continent].append(farm)
+        return location_dict
+
+    def get_all_farms_nodes(self, farms, cru=None, sru=None, mru=None, hru=None, currency="TFT", filter_blocked=True):
+        if j.config.get("OVER_PROVISIONING"):
+            cru = 0
+            mru = 0
+        nodes = []
+        for farm in farms:
+            candidate_nodes = j.sals.zos.get().nodes_finder.nodes_by_capacity(
+                farm_id=farm.id, cru=cru, mru=mru, hru=hru, sru=sru, currency=currency
+            )
+            candidate_nodes = list(filter(j.sals.zos.get().nodes_finder.filter_is_up, candidate_nodes))
+            candidate_nodes = list(filter(j.sals.zos.get().nodes_finder.filter_public_ip6, candidate_nodes))
+            nodes += candidate_nodes
+        if filter_blocked:
+            disallowed_node_ids = set(j.sals.reservation_chatflow.reservation_chatflow.list_blocked_nodes().keys())
+            nodes = [node for node in nodes if node.node_id not in disallowed_node_ids]
+        return nodes
+
 
 deployer = MarketPlaceDeployer()
diff --git a/jumpscale/sals/marketplace/solutions.py b/jumpscale/sals/marketplace/solutions.py
index 0eb2569801..c02d6094e4 100644
--- a/jumpscale/sals/marketplace/solutions.py
+++ b/jumpscale/sals/marketplace/solutions.py
@@ -7,9 +7,7 @@
 
 class MarketplaceSolutions(ChatflowSolutions):
     def list_network_solutions(self, username, next_action=NextAction.DEPLOY, sync=True):
-        networks = j.sals.marketplace.deployer.list_networks(username, next_action=next_action, sync=sync)
-        if not sync and not networks:
-            networks = j.sals.marketplace.deployer.list_networks(username, next_action=next_action, sync=False)
+        networks = j.sals.marketplace.deployer.list_networks(username, next_action=next_action)
         result = []
         for n in networks.values():
             if len(n.network_workloads) == 0:
diff --git a/jumpscale/sals/reservation_chatflow/deployer.py b/jumpscale/sals/reservation_chatflow/deployer.py
index fd220099ce..b033728f76 100644
--- a/jumpscale/sals/reservation_chatflow/deployer.py
+++ b/jumpscale/sals/reservation_chatflow/deployer.py
@@ -60,7 +60,7 @@ def __exit__(self, exc_type, exc, exc_tb):
         if exc.solution_uuid:
             # cancel related workloads
             j.logger.info(f"canceling workload ids of solution_uuid: {exc.solution_uuid}")
-            j.sals.reservation_chatflow.solutions.cancel_solution_by_uuid(exc.solution_uuid)
+            j.sals.reservation_chatflow.solutions.cancel_solution_by_uuid(exc.solution_uuid, exc.identity_name)
         if exc.wid:
             # block the failed node if the workload is network or container
             zos = j.sals.zos.get(exc.identity_name)
@@ -72,26 +72,29 @@ def __exit__(self, exc_type, exc, exc_tb):
 
 class NetworkView:
     class dry_run_context(ContextDecorator):
-        def __init__(self, test_network_name, *args, **kwargs):
+        def __init__(self, test_network_name, identity_name=None, *args, **kwargs):
             super().__init__(*args, **kwargs)
             self.test_network_name = test_network_name
+            self.identity_name = identity_name or j.core.identity.me.instance_name
 
         def __enter__(self):
             return self
 
         def __exit__(self, *exc):
-            network_view = NetworkView(self.test_network_name)
+            network_view = NetworkView(self.test_network_name, identity_name=self.identity_name)
             for workload in network_view.network_workloads:
-                j.sals.zos.get().workloads.decomission(workload.id)
+                j.sals.zos.get(self.identity_name).workloads.decomission(workload.id)
 
-    def __init__(self, name, workloads=None, nodes=None):
+    def __init__(self, name, workloads=None, nodes=None, identity_name=None):
+        self.identity_name = identity_name or j.core.identity.me.instance_name
         self.name = name
+        identity_tid = j.core.identity.get(self.identity_name).tid
         if not workloads:
-            workloads = j.sals.zos.get().workloads.list(j.core.identity.me.tid, NextAction.DEPLOY)
+            workloads = j.sals.zos.get(self.identity_name).workloads.list(identity_tid, NextAction.DEPLOY)
         self.workloads = workloads
         self.used_ips = []
         self.network_workloads = []
-        nodes = nodes or {node.node_id for node in j.sals.zos.get()._explorer.nodes.list()}
+        nodes = nodes or {node.node_id for node in j.sals.zos.get(self.identity_name)._explorer.nodes.list()}
         self._fill_used_ips(self.workloads, nodes)
         self._init_network_workloads(self.workloads, nodes)
         if self.network_workloads:
@@ -100,7 +103,7 @@ def __init__(self, name, workloads=None, nodes=None):
             self.iprange = "can't be retrieved"
 
     def _init_network_workloads(self, workloads, nodes=None):
-        nodes = nodes or {node.node_id for node in j.sals.zos.get()._explorer.nodes.list()}
+        nodes = nodes or {node.node_id for node in j.sals.zos.get(self.identity_name)._explorer.nodes.list()}
         for workload in workloads:
             if workload.info.node_id not in nodes:
                 continue
@@ -110,7 +113,7 @@ def _init_network_workloads(self, workloads, nodes=None):
                 self.network_workloads.append(workload)
 
     def _fill_used_ips(self, workloads, nodes=None):
-        nodes = nodes or {node.node_id for node in j.sals.zos.get()._explorer.nodes.list()}
+        nodes = nodes or {node.node_id for node in j.sals.zos.get(self.identity_name)._explorer.nodes.list()}
         for workload in workloads:
             if workload.info.node_id not in nodes:
                 continue
@@ -138,12 +141,12 @@ def add_node(self, node, pool_id):
                     break
             else:
                 raise StopChatFlow("Failed to find free network")
-            network = j.sals.zos.get().network.create(self.iprange, self.name)
+            network = j.sals.zos.get(self.identity_name).network.create(self.iprange, self.name)
             node_workloads = {}
             for net_workload in self.network_workloads:
                 node_workloads[net_workload.info.node_id] = net_workload
             network.network_resources = list(node_workloads.values())  # add only latest network resource for each node
-            j.sals.zos.get().network.add_node(network, node.node_id, str(subnet), pool_id)
+            j.sals.zos.get(self.identity_name).network.add_node(network, node.node_id, str(subnet), pool_id)
             return network
 
     def add_multiple_nodes(self, node_ids, pool_ids):
@@ -203,14 +206,14 @@ def add_access(self, node_id=None, use_ipv4=True, pool_id=None):
                     break
             else:
                 raise StopChatFlow("Failed to find free network")
-        network = j.sals.zos.get().network.create(self.iprange, self.name)
+        network = j.sals.zos.get(self.identity_name).network.create(self.iprange, self.name)
         node_workloads = {}
         for net_workload in self.network_workloads:
             node_workloads[net_workload.info.node_id] = net_workload
         network.network_resources = list(node_workloads.values())  # add only latest network resource for each node
         if node_id not in node_workloads:
-            j.sals.zos.get().network.add_node(network, node_id, str(subnet), pool_id=pool_id)
-        wg_quick = j.sals.zos.get().network.add_access(network, node_id, str(subnet), ipv4=use_ipv4)
+            j.sals.zos.get(self.identity_name).network.add_node(network, node_id, str(subnet), pool_id=pool_id)
+        wg_quick = j.sals.zos.get(self.identity_name).network.add_access(network, node_id, str(subnet), ipv4=use_ipv4)
         return network, wg_quick
 
     def delete_access(self, ip_range, node_id=None):
@@ -218,9 +221,9 @@ def delete_access(self, ip_range, node_id=None):
         node_workloads = {}
         for net_workload in self.network_workloads:
             node_workloads[net_workload.info.node_id] = net_workload
-        network = j.sals.zos.get().network.create(self.iprange, self.name)
+        network = j.sals.zos.get(self.identity_name).network.create(self.iprange, self.name)
         network.network_resources = list(node_workloads.values())
-        network = j.sals.zos.get().network.delete_access(network, node_id, ip_range)
+        network = j.sals.zos.get(self.identity_name).network.delete_access(network, node_id, ip_range)
         return network
 
     def get_node_range(self, node):
@@ -232,7 +235,7 @@ def get_node_range(self, node):
         raise StopChatFlow(f"Node {node.node_id} is not part of network")
 
     def copy(self):
-        return NetworkView(self.name)
+        return NetworkView(self.name, identity_name=self.identity_name)
 
     def get_node_free_ips(self, node):
         ip_range = self.get_node_range(node)
@@ -276,17 +279,19 @@ def dry_run(self, test_network_name=None, node_ids=None, pool_ids=None, bot=None
             pool_ids = list(node_pool_dict.values())
 
         node_ids = list(set(node_ids))
-        network = j.sals.zos.get().network.create(str(ip_range), name)
+        network = j.sals.zos.get(self.identity_name).network.create(str(ip_range), name)
         for idx, subnet in enumerate(ip_range.subnet(24)):
             if idx == len(node_ids):
                 break
-            j.sals.zos.get().network.add_node(network, node_ids[idx], str(subnet), node_pool_dict[node_ids[idx]])
+            j.sals.zos.get(self.identity_name).network.add_node(
+                network, node_ids[idx], str(subnet), node_pool_dict[node_ids[idx]]
+            )
         result = []
         for resource in network.network_resources:
             if bot:
                 bot.md_show_update(f"testing deployment on node {resource.info.node_id}")
             try:
-                result.append(j.sals.zos.get().workloads.deploy(resource))
+                result.append(j.sals.zos.get(self.identity_name).workloads.deploy(resource))
             except Exception as e:
                 raise StopChatFlow(
                     f"failed to deploy workload on node {resource.info.node_id} due to" f" error {str(e)}"
@@ -295,7 +300,7 @@ def dry_run(self, test_network_name=None, node_ids=None, pool_ids=None, bot=None
             try:
                 deployer.wait_workload(wid, bot, 2)
             except StopChatFlow:
-                workload = j.sals.zos.get().workloads.get(wid)
+                workload = j.sals.zos.get(self.identity_name).workloads.get(wid)
                 # if not a breaking nodes (old node not used for deployment) we can overlook it
                 if workload.info.node_id not in breaking_node_ids:
                     continue
@@ -331,13 +336,16 @@ def load_user_workloads(self, next_action=NextAction.DEPLOY):
                 workload
             )
 
-    def decrypt_metadata(self, encrypted_metadata):
+    def decrypt_metadata(self, encrypted_metadata, identity_name=None):
+        identity_name = identity_name or j.core.identity.me.instance_name
+        identity = j.core.identity.get(identity_name)
         try:
-            pk = j.core.identity.me.nacl.signing_key.verify_key.to_curve25519_public_key()
-            sk = j.core.identity.me.nacl.signing_key.to_curve25519_private_key()
+            pk = identity.nacl.signing_key.verify_key.to_curve25519_public_key()
+            sk = identity.nacl.signing_key.to_curve25519_private_key()
             box = Box(sk, pk)
             return box.decrypt(base64.b85decode(encrypted_metadata.encode())).decode()
-        except:
+        except Exception as e:
+            j.logger.error(f"error when decrypting metadata. {str(e)}")
             return "{}"
 
     def list_networks(self, next_action=NextAction.DEPLOY, sync=True):
@@ -665,23 +673,25 @@ def ask_ipv6(self, bot, workload_name=None):
         )
         return ipv6 == "YES"
 
-    def encrypt_metadata(self, metadata):
+    def encrypt_metadata(self, metadata, identity_name=None):
         if isinstance(metadata, dict):
             metadata = j.data.serializers.json.dumps(metadata)
-        pk = j.core.identity.me.nacl.signing_key.verify_key.to_curve25519_public_key()
-        sk = j.core.identity.me.nacl.signing_key.to_curve25519_private_key()
+        identity_name = identity_name or j.core.identity.me.instance_name
+        pk = j.core.identity.get(identity_name).nacl.signing_key.verify_key.to_curve25519_public_key()
+        sk = j.core.identity.get(identity_name).nacl.signing_key.to_curve25519_private_key()
         box = Box(sk, pk)
         encrypted_metadata = base64.b85encode(box.encrypt(metadata.encode())).decode()
         return encrypted_metadata
 
-    def deploy_network(self, name, access_node, ip_range, ip_version, pool_id, **metadata):
-        network = j.sals.zos.get().network.create(ip_range, name)
+    def deploy_network(self, name, access_node, ip_range, ip_version, pool_id, identity_name=None, **metadata):
+        identity_name = identity_name or j.core.identity.me.instance_name
+        network = j.sals.zos.get(identity_name).network.create(ip_range, name)
         node_subnets = netaddr.IPNetwork(ip_range).subnet(24)
         network_config = dict()
         use_ipv4 = ip_version == "IPv4"
 
-        j.sals.zos.get().network.add_node(network, access_node.node_id, str(next(node_subnets)), pool_id)
-        wg_quick = j.sals.zos.get().network.add_access(
+        j.sals.zos.get(identity_name).network.add_node(network, access_node.node_id, str(next(node_subnets)), pool_id)
+        wg_quick = j.sals.zos.get(identity_name).network.add_access(
             network, access_node.node_id, str(next(node_subnets)), ipv4=use_ipv4
         )
 
@@ -694,26 +704,45 @@ def deploy_network(self, name, access_node, ip_range, ip_version, pool_id, **met
         for workload in network.network_resources:
             workload.info.description = j.data.serializers.json.dumps({"parent_id": parent_id})
             metadata["parent_network"] = parent_id
-            workload.info.metadata = self.encrypt_metadata(metadata)
-            ids.append(j.sals.zos.get().workloads.deploy(workload))
+            workload.info.metadata = self.encrypt_metadata(metadata, identity_name)
+            ids.append(j.sals.zos.get(identity_name).workloads.deploy(workload))
             parent_id = ids[-1]
         network_config["ids"] = ids
         network_config["rid"] = ids[0]
         return network_config
 
     def add_access(
-        self, network_name, network_view=None, node_id=None, pool_id=None, use_ipv4=True, bot=None, **metadata
+        self,
+        network_name,
+        network_view=None,
+        node_id=None,
+        pool_id=None,
+        use_ipv4=True,
+        bot=None,
+        identity_name=None,
+        **metadata,
     ):
-        network_view = network_view or NetworkView(network_name)
+        identity_name = identity_name or j.core.identity.me.instance_name
+        network_view = network_view or NetworkView(network_name, identity_name=identity_name)
         network, wg = network_view.add_access(node_id, use_ipv4, pool_id)
         result = {"ids": [], "wg": wg}
         node_workloads = {}
         # deploy only latest resource generated by zos sal for each node
+        owner = None
+        node_metadata = defaultdict(dict)  # node_id: metadata dict
         for workload in network.network_resources:
             node_workloads[workload.info.node_id] = workload
+            decrypted_metadata = self.decrypt_metadata(workload.info.metadata, identity_name)
+            metadata_dict = j.data.serializers.json.loads(decrypted_metadata)
+            node_metadata[workload.info.node_id].update(metadata_dict)
+            if not owner and metadata_dict.get("owner"):
+                owner = metadata_dict["owner"]
+
+        if owner and "owner" not in metadata:
+            metadata["owner"] = owner
 
         dry_run_name = uuid.uuid4().hex
-        with NetworkView.dry_run_context(dry_run_name):
+        with NetworkView.dry_run_context(dry_run_name, identity_name):
             network_view.dry_run(
                 dry_run_name,
                 list(node_workloads.keys()),
@@ -727,22 +756,38 @@ def add_access(
             resource.info.reference = ""
             resource.info.description = j.data.serializers.json.dumps({"parent_id": parent_id})
             metadata["parent_network"] = parent_id
-            resource.info.metadata = self.encrypt_metadata(metadata)
-            result["ids"].append(j.sals.zos.get().workloads.deploy(resource))
+            old_metadata = node_metadata.get(resource.info.node_id, {})
+            old_metadata.pop("parent_network", None)
+            metadata.update(old_metadata)
+            resource.info.metadata = self.encrypt_metadata(metadata, identity_name)
+            result["ids"].append(j.sals.zos.get(identity_name).workloads.deploy(resource))
             parent_id = result["ids"][-1]
         result["rid"] = result["ids"][0]
         return result
 
-    def delete_access(self, network_name, iprange, network_view=None, node_id=None, bot=None, **metadata):
+    def delete_access(
+        self, network_name, iprange, network_view=None, node_id=None, bot=None, identity_name=None, **metadata
+    ):
         network_view = network_view or NetworkView(network_name)
         network = network_view.delete_access(iprange, node_id)
 
         node_workloads = {}
         # deploy only latest resource generated by zos sal for each node
+        owner = None
+        node_metadata = defaultdict(dict)
         for workload in network.network_resources:
             node_workloads[workload.info.node_id] = workload
+            decrypted_metadata = self.decrypt_metadata(workload.info.metadata, identity_name)
+            metadata_dict = j.data.serializers.json.loads(decrypted_metadata)
+            node_metadata[workload.info.node_id].update(metadata_dict)
+            if not owner and metadata_dict.get("owner"):
+                owner = metadata_dict["owner"]
+
+        if owner and "owner" not in metadata:
+            metadata["owner"] = owner
+
         dry_run_name = uuid.uuid4().hex
-        with NetworkView.dry_run_context(dry_run_name):
+        with NetworkView.dry_run_context(dry_run_name, identity_name):
             network_view.dry_run(
                 dry_run_name,
                 list(node_workloads.keys()),
@@ -756,22 +801,34 @@ def delete_access(self, network_name, iprange, network_view=None, node_id=None,
             resource.info.reference = ""
             resource.info.description = j.data.serializers.json.dumps({"parent_id": parent_id})
             metadata["parent_network"] = parent_id
-            resource.info.metadata = self.encrypt_metadata(metadata)
+            old_metadata = node_metadata.get(resource.info.node_id, {})
+            old_metadata.pop("parent_network", None)
+            metadata.update(old_metadata)
+            resource.info.metadata = self.encrypt_metadata(metadata, identity_name)
             result.append(j.sals.zos.get().workloads.deploy(resource))
             parent_id = result[-1]
         return result
 
-    def wait_workload(self, workload_id, bot=None, expiry=10, breaking_node_id=None):
+    def wait_workload(self, workload_id, bot=None, expiry=10, breaking_node_id=None, identity_name=None):
+        j.logger.info(f"waiting workload {workload_id} to finish deployment")
         expiry = expiry or 10
         expiration_provisioning = j.data.time.now().timestamp + expiry * 60
 
-        workload = j.sals.zos.get().workloads.get(workload_id)
+        workload = j.sals.zos.get(identity_name).workloads.get(workload_id)
+        # if the workload is network and it is not a breaking node, skip if the node is blocked
+        if (
+            workload.info.workload_type == WorkloadType.Network_resource
+            and workload.info.node_id in j.sals.reservation_chatflow.reservation_chatflow.list_blocked_nodes()
+        ):
+            if workload.info.node_id != breaking_node_id:
+                return True
+
         if workload.info.workload_type in GATEWAY_WORKLOAD_TYPES:
-            node = self._explorer.gateway.get(workload.info.node_id)
+            node = j.sals.zos.get(identity_name)._explorer.gateway.get(workload.info.node_id)
         else:
-            node = self._explorer.nodes.get(workload.info.node_id)
+            node = j.sals.zos.get(identity_name)._explorer.nodes.get(workload.info.node_id)
         # check if the node is up
-        if not j.sals.zos.get().nodes_finder.filter_is_up(node):
+        if not j.sals.zos.get(identity_name).nodes_finder.filter_is_up(node):
             cancel = True
             if breaking_node_id and breaking_node_id == node.node_id:
                 # if the node is down and it is the same as breaking_node_id
@@ -783,12 +840,12 @@ def wait_workload(self, workload_id, bot=None, expiry=10, breaking_node_id=None)
                 # if the workload is network we can overlook it
                 return True
             if cancel:
-                j.sals.reservation_chatflow.solutions.cancel_solution([workload_id])
+                j.sals.reservation_chatflow.solutions.cancel_solution([workload_id], identity_name)
             raise StopChatFlow(f"Workload {workload_id} failed to deploy because the node is down {node.node_id}")
 
         # wait for workload
         while True:
-            workload = j.sals.zos.get().workloads.get(workload_id)
+            workload = j.sals.zos.get(identity_name).workloads.get(workload_id)
             remaning_time = j.data.time.get(expiration_provisioning).humanize(granularity=["minute", "second"])
             if bot:
                 deploying_message = f"""\
@@ -815,15 +872,16 @@ def wait_workload(self, workload_id, bot=None, expiry=10, breaking_node_id=None)
             if expiration_provisioning < j.data.time.get().timestamp:
                 j.sals.reservation_chatflow.reservation_chatflow.block_node(workload.info.node_id)
                 if workload.info.workload_type != WorkloadType.Network_resource:
-                    j.sals.reservation_chatflow.solutions.cancel_solution([workload_id])
+                    j.sals.reservation_chatflow.solutions.cancel_solution([workload_id], identity_name)
                 elif breaking_node_id and workload.info.node_id != breaking_node_id:
                     return True
                 raise StopChatFlow(f"Workload {workload_id} failed to deploy in time")
             gevent.sleep(1)
 
-    def add_network_node(self, name, node, pool_id, network_view=None, bot=None, **metadata):
+    def add_network_node(self, name, node, pool_id, network_view=None, bot=None, identity_name=None, **metadata):
+        identity_name = identity_name or j.core.identity.me.instance_name
         if not network_view:
-            network_view = NetworkView(name)
+            network_view = NetworkView(name, identity_name=identity_name)
         network = network_view.add_node(node, pool_id)
         if not network:
             return
@@ -831,10 +889,21 @@ def add_network_node(self, name, node, pool_id, network_view=None, bot=None, **m
         ids = []
         node_workloads = {}
         # deploy only latest resource generated by zos sal for each node
+        owner = None
+        node_metadata = defaultdict(dict)
         for workload in network.network_resources:
             node_workloads[workload.info.node_id] = workload
+            decrypted_metadata = self.decrypt_metadata(workload.info.metadata, identity_name)
+            metadata_dict = j.data.serializers.json.loads(decrypted_metadata)
+            node_metadata[workload.info.node_id].update(metadata_dict)
+            if not owner and metadata_dict.get("owner"):
+                owner = metadata_dict["owner"]
+
+        if owner and "owner" not in metadata:
+            metadata["owner"] = owner
+
         dry_run_name = uuid.uuid4().hex
-        with NetworkView.dry_run_context(dry_run_name):
+        with NetworkView.dry_run_context(dry_run_name, identity_name):
             network_view.dry_run(
                 dry_run_name,
                 list(node_workloads.keys()),
@@ -846,8 +915,11 @@ def add_network_node(self, name, node, pool_id, network_view=None, bot=None, **m
             workload.info.reference = ""
             workload.info.description = j.data.serializers.json.dumps({"parent_id": parent_id})
             metadata["parent_network"] = parent_id
-            workload.info.metadata = self.encrypt_metadata(metadata)
-            ids.append(j.sals.zos.get().workloads.deploy(workload))
+            old_metadata = node_metadata.get(workload.info.node_id, {})
+            old_metadata.pop("parent_network", None)
+            metadata.update(old_metadata)
+            workload.info.metadata = self.encrypt_metadata(metadata, identity_name)
+            ids.append(j.sals.zos.get(identity_name).workloads.deploy(workload))
             parent_id = ids[-1]
         return {"ids": ids, "rid": ids[0]}
 
@@ -913,18 +985,20 @@ def deploy_container(
         volumes=None,
         log_config=None,
         public_ipv6=False,
+        identity_name=None,
         **metadata,
     ):
         """
         volumes: dict {"mountpoint (/)": volume_id}
         log_Config: dict. keys ("channel_type", "channel_host", "channel_port", "channel_name")
         """
+        identity_name = identity_name or j.core.identity.me.instance_name
         env = env or {}
         encrypted_secret_env = {}
         if secret_env:
             for key, val in secret_env.items():
-                encrypted_secret_env[key] = j.sals.zos.get().container.encrypt_secret(node_id, val)
-        container = j.sals.zos.get().container.create(
+                encrypted_secret_env[key] = j.sals.zos.get(identity_name).container.encrypt_secret(node_id, val)
+        container = j.sals.zos.get(identity_name).container.create(
             node_id,
             network_name,
             ip_address,
@@ -941,12 +1015,12 @@ def deploy_container(
         )
         if volumes:
             for mount_point, vol_id in volumes.items():
-                j.sals.zos.get().volume.attach_existing(container, f"{vol_id}-1", mount_point)
+                j.sals.zos.get(identity_name).volume.attach_existing(container, f"{vol_id}-1", mount_point)
         if metadata:
-            container.info.metadata = self.encrypt_metadata(metadata)
+            container.info.metadata = self.encrypt_metadata(metadata, identity_name=identity_name)
         if log_config:
-            j.sals.zos.get().container.add_logs(container, **log_config)
-        return j.sals.zos.get().workloads.deploy(container)
+            j.sals.zos.get(identity_name).container.add_logs(container, **log_config)
+        return j.sals.zos.get(identity_name).workloads.deploy(container)
 
     def ask_container_resources(
         self,
@@ -1058,8 +1132,8 @@ def calculate_capacity_units(self, cru=0, mru=0, sru=0, hru=0):
             su = 0
         return cu, su
 
-    def get_network_view(self, network_name, workloads=None):
-        return NetworkView(network_name, workloads)
+    def get_network_view(self, network_name, workloads=None, identity_name=None):
+        return NetworkView(network_name, workloads, identity_name=identity_name)
 
     def delegate_domain(self, pool_id, gateway_id, domain_name, **metadata):
         domain_delegate = j.sals.zos.get().gateway.delegate_domain(gateway_id, domain_name, pool_id)
@@ -1226,7 +1300,7 @@ def list_pool_gateways(self, pool_id):
             result[f"{g.dns_nameserver[0]} {g.location.continent} {g.location.country}" f" {g.node_id}"] = g
         return result
 
-    def list_all_gateways(self, pool_ids=None):
+    def list_all_gateways(self, pool_ids=None, identity_name=None):
         """
         Args:
             pool_ids: if specified it will only list gateways inside these pools
@@ -1234,10 +1308,11 @@ def list_all_gateways(self, pool_ids=None):
         Returns:
             dict: {"gateway_message": {"gateway": g, "pool": pool},}
         """
-        all_gateways = filter(j.sals.zos.get().nodes_finder.filter_is_up, self._explorer.gateway.list())
+        identity_name = identity_name or j.core.identity.me.instance_name
+        all_gateways = filter(j.sals.zos.get(identity_name).nodes_finder.filter_is_up, self._explorer.gateway.list())
         if not all_gateways:
             raise StopChatFlow(f"no available gateways")
-        all_pools = [p for p in j.sals.zos.get().pools.list() if p.node_ids]
+        all_pools = [p for p in j.sals.zos.get(identity_name).pools.list() if p.node_ids]
         available_node_ids = {}  # node_id: pool
         if pool_ids is not None:
             for pool in all_pools:
@@ -1304,27 +1379,29 @@ def deploy_zdb(self, pool_id, node_id, size, mode, password, disk_type="SSD", pu
             workload.info.metadata = self.encrypt_metadata(metadata)
         return j.sals.zos.get().workloads.deploy(workload)
 
-    def create_subdomain(self, pool_id, gateway_id, subdomain, addresses=None, **metadata):
+    def create_subdomain(self, pool_id, gateway_id, subdomain, addresses=None, identity_name=None, **metadata):
         """
         creates an A record pointing to the specified addresses
         if no addresses are specified, the record will point the gateway IP address (used for exposing solutions)
         """
+        identity_name = identity_name or j.core.identity.me.instance_name
         if not addresses:
             gateway = self._explorer.gateway.get(gateway_id)
             addresses = [j.sals.nettools.get_host_by_name(ns) for ns in gateway.dns_nameserver]
-        workload = j.sals.zos.get().gateway.sub_domain(gateway_id, subdomain, addresses, pool_id)
+        workload = j.sals.zos.get(identity_name).gateway.sub_domain(gateway_id, subdomain, addresses, pool_id)
         if metadata:
-            workload.info.metadata = self.encrypt_metadata(metadata)
-        return j.sals.zos.get().workloads.deploy(workload)
+            workload.info.metadata = self.encrypt_metadata(metadata, identity_name)
+        return j.sals.zos.get(identity_name).workloads.deploy(workload)
 
-    def create_proxy(self, pool_id, gateway_id, domain_name, trc_secret, **metadata):
+    def create_proxy(self, pool_id, gateway_id, domain_name, trc_secret, identity_name=None, **metadata):
         """
         creates a reverse tunnel on the gateway node
         """
-        workload = j.sals.zos.get().gateway.tcp_proxy_reverse(gateway_id, domain_name, trc_secret, pool_id)
+        identity_name = identity_name or j.core.identity.me.instance_name
+        workload = j.sals.zos.get(identity_name).gateway.tcp_proxy_reverse(gateway_id, domain_name, trc_secret, pool_id)
         if metadata:
-            workload.info.metadata = self.encrypt_metadata(metadata)
-        return j.sals.zos.get().workloads.deploy(workload)
+            workload.info.metadata = self.encrypt_metadata(metadata, identity_name)
+        return j.sals.zos.get(identity_name).workloads.deploy(workload)
 
     def expose_and_create_certificate(
         self,
@@ -1437,17 +1514,26 @@ def expose_address(
         domain_name=None,
         bot=None,
         log_config=None,
+        identity_name=None,
         **metadata,
     ):
+        identity_name = identity_name or j.core.identity.me.instance_name
         proxy_pool_id = proxy_pool_id or pool_id
         gateway = self._explorer.gateway.get(gateway_id)
 
+        reverse_id = None
         if reserve_proxy:
             if not domain_name:
                 raise StopChatFlow("you must pass domain_name when you ise reserv_proxy")
             resv_id = self.create_proxy(
-                pool_id=proxy_pool_id, gateway_id=gateway_id, domain_name=domain_name, trc_secret=trc_secret, **metadata
+                pool_id=proxy_pool_id,
+                gateway_id=gateway_id,
+                domain_name=domain_name,
+                trc_secret=trc_secret,
+                identity_name=identity_name,
+                **metadata,
             )
+            reverse_id = resv_id
             success = self.wait_workload(resv_id)
             if not success:
                 raise DeploymentFailed(
@@ -1464,7 +1550,7 @@ def expose_address(
         else:
             node = self._explorer.nodes.get(node_id)
 
-        res = self.add_network_node(network_name, node, pool_id, bot=bot)
+        res = self.add_network_node(network_name, node, pool_id, identity_name=identity_name, bot=bot)
         if res:
             for wid in res["ids"]:
                 success = self.wait_workload(wid, bot, breaking_node_id=node.node_id)
@@ -1476,7 +1562,7 @@ def expose_address(
                         wid=wid,
                         solution_uuid=metadata.get("solution_uuid"),
                     )
-        network_view = NetworkView(network_name)
+        network_view = NetworkView(network_name, identity_name=identity_name)
         network_view = network_view.copy()
         network_view.used_ips.append(local_ip)
         ip_address = network_view.get_free_ip(node)
@@ -1499,9 +1585,10 @@ def expose_address(
             env=env,
             public_ipv6=False,
             log_config=log_config,
+            identity_name=identity_name,
             **metadata,
         )
-        return resv_id
+        return resv_id, reverse_id
 
     def deploy_minio_zdb(
         self,
@@ -1748,12 +1835,12 @@ def chatflow_network_check(self, bot):
             raise StopChatFlow("You don't have any deployed networks. Please create one first.")
         bot.all_network_viewes = networks
 
-    def wait_demo_payment(self, bot, pool_id, exp=5, trigger_cus=0, trigger_sus=1):
+    def wait_demo_payment(self, bot, pool_id, exp=5, trigger_cus=0, trigger_sus=1, identity_name=None):
         expiration = j.data.time.now().timestamp + exp * 60
         msg = "<h2> Waiting for resources provisioning...</h2>"
         while j.data.time.get().timestamp < expiration:
             bot.md_show_update(msg, html=True)
-            pool = j.sals.zos.get().pools.get(pool_id)
+            pool = j.sals.zos.get(identity_name).pools.get(pool_id)
             if pool.cus >= trigger_cus and pool.sus >= trigger_sus:
                 bot.md_show_update("Preparing app resources")
                 return True
@@ -1761,7 +1848,7 @@ def wait_demo_payment(self, bot, pool_id, exp=5, trigger_cus=0, trigger_sus=1):
 
         return False
 
-    def wait_pool_payment(self, bot, pool_id, exp=5, qr_code=None, trigger_cus=0, trigger_sus=1):
+    def wait_pool_payment(self, bot, pool_id, exp=5, qr_code=None, trigger_cus=0, trigger_sus=1, identity_name=None):
         expiration = j.data.time.now().timestamp + exp * 60
         msg = "<h2> Waiting for payment...</h2>"
         if qr_code:
@@ -1772,11 +1859,11 @@ def wait_pool_payment(self, bot, pool_id, exp=5, qr_code=None, trigger_cus=0, tr
                 <img style="border:1px dashed #85929E" src="data:image/png;base64,{qr_encoded}"/>
             </div>
             """
-            pool = j.sals.zos.get().pools.get(pool_id)
+            pool = j.sals.zos.get(identity_name).pools.get(pool_id)
             msg = msg + self.msg_payment_info + qr_code_msg
         while j.data.time.get().timestamp < expiration:
             bot.md_show_update(msg, html=True)
-            pool = j.sals.zos.get().pools.get(pool_id)
+            pool = j.sals.zos.get(identity_name).pools.get(pool_id)
             if pool.cus >= trigger_cus and pool.sus >= trigger_sus:
                 bot.md_show_update("Preparing app resources")
                 return True
@@ -1818,11 +1905,12 @@ def get_qr_code_payment_info(self, pool):
 
         return msg_text, qr_code
 
-    def test_managed_domain(self, gateway_id, managed_domain, pool_id, gateway=None):
+    def test_managed_domain(self, gateway_id, managed_domain, pool_id, gateway=None, identity_name=None):
+        identity_name = identity_name or j.core.identity.me.instance_name
         gateway = gateway or self._explorer.gateway.get(gateway_id)
         subdomain = f"{uuid.uuid4().hex}.{managed_domain}"
         addresses = [j.sals.nettools.get_host_by_name(gateway.dns_nameserver[0])]
-        subdomain_id = self.create_subdomain(pool_id, gateway_id, subdomain, addresses)
+        subdomain_id = self.create_subdomain(pool_id, gateway_id, subdomain, addresses, identity_name=identity_name)
         success = self.wait_workload(subdomain_id)
         if not success:
             return False
@@ -1830,16 +1918,16 @@ def test_managed_domain(self, gateway_id, managed_domain, pool_id, gateway=None)
             j.sals.nettools.get_host_by_name(subdomain)
         except Exception as e:
             j.logger.error(f"managed domain test failed for {managed_domain} due to error {str(e)}")
-            j.sals.zos.get().workloads.decomission(subdomain_id)
+            j.sals.zos.get(identity_name).workloads.decomission(subdomain_id)
             return False
-        j.sals.zos.get().workloads.decomission(subdomain_id)
+        j.sals.zos.get(identity_name).workloads.decomission(subdomain_id)
         return True
 
     def block_managed_domain(self, managed_domain):
         count = j.core.db.hincrby(DOMAINS_COUNT_KEY, managed_domain)
         expiration = count * DOMAINS_DISALLOW_EXPIRATION
         domain_key = f"{DOMAINS_DISALLOW_PREFIX}:{managed_domain}"
-        j.core.db.set(domain_key, expiration, ex=expiration)
+        j.core.db.set(domain_key, j.data.time.utcnow().timestamp + expiration, ex=expiration)
 
     def unblock_managed_domain(self, managed_domain, reset=True):
         domain_key = f"{DOMAINS_DISALLOW_PREFIX}:{managed_domain}"
diff --git a/jumpscale/sals/reservation_chatflow/reservation_chatflow.py b/jumpscale/sals/reservation_chatflow/reservation_chatflow.py
index 7d27adf8a1..0dfe41a966 100644
--- a/jumpscale/sals/reservation_chatflow/reservation_chatflow.py
+++ b/jumpscale/sals/reservation_chatflow/reservation_chatflow.py
@@ -1377,6 +1377,7 @@ def get_nodes(
         ip_version=None,
         pool_ids=None,
         filter_blocked=True,
+        identity_name=None,
         sort_by_disk_space=False,
     ):
         """get available nodes to deploy solutions on
@@ -1421,7 +1422,7 @@ def filter_disallowed_nodes(disallowed_node_ids, nodes):
             nodes_number = nodes_distribution[pool_id]
             if not pool_ids:
                 pool_id = None
-            nodes = j.sals.zos.get().nodes_finder.nodes_by_capacity(
+            nodes = j.sals.zos.get(identity_name).nodes_finder.nodes_by_capacity(
                 cru=cru, sru=sru, mru=mru, hru=hru, currency=currency, pool_id=pool_id
             )
             nodes = filter_disallowed_nodes(disallowed_node_ids, nodes)
@@ -1615,7 +1616,7 @@ def block_node(self, node_id):
         count = j.core.db.hincrby(NODES_COUNT_KEY, node_id)
         expiration = count * NODES_DISALLOW_EXPIRATION
         node_key = f"{NODES_DISALLOW_PREFIX}:{node_id}"
-        j.core.db.set(node_key, expiration, ex=expiration)
+        j.core.db.set(node_key, j.data.time.utcnow().timestamp + expiration, ex=expiration)
 
     def unblock_node(self, node_id, reset=True):
         node_key = f"{NODES_DISALLOW_PREFIX}:{node_id}"
diff --git a/jumpscale/sals/reservation_chatflow/solutions.py b/jumpscale/sals/reservation_chatflow/solutions.py
index de6734bba2..805167508c 100644
--- a/jumpscale/sals/reservation_chatflow/solutions.py
+++ b/jumpscale/sals/reservation_chatflow/solutions.py
@@ -291,23 +291,26 @@ def list_exposed_solutions(self, next_action=NextAction.DEPLOY, sync=True):
                     result[domain]["wids"].append(container_workload.id)
         return list(result.values())
 
-    def cancel_solution(self, solution_wids):
+    def cancel_solution(self, solution_wids, identity_name=None):
         """
         solution_wids should be part of the same solution. if they are not created by the same solution they may not all be deleted
         """
-        workload = j.sals.zos.get().workloads.get(solution_wids[0])
-        solution_uuid = self.get_solution_uuid(workload)
+        identity_name = identity_name or j.core.identity.me.instance_name
+        workload = j.sals.zos.get(identity_name).workloads.get(solution_wids[0])
+        solution_uuid = self.get_solution_uuid(workload, identity_name)
         ids_to_delete = []
         if solution_uuid:
             # solutions created by new chatflows
-            for workload in j.sals.zos.get().workloads.list(j.core.identity.me.tid, next_action="DEPLOY"):
-                if solution_uuid == self.get_solution_uuid(workload):
+            for workload in j.sals.zos.get(identity_name).workloads.list(
+                j.core.identity.get(identity_name).tid, next_action="DEPLOY"
+            ):
+                if solution_uuid == self.get_solution_uuid(workload, identity_name):
                     ids_to_delete.append(workload.id)
         else:
             ids_to_delete = solution_wids
 
         for wid in ids_to_delete:
-            j.sals.zos.get().workloads.decomission(wid)
+            j.sals.zos.get(identity_name).workloads.decomission(wid)
 
     def count_solutions(self, next_action=NextAction.DEPLOY):
         count_dict = {
@@ -340,11 +343,11 @@ def count_solutions(self, next_action=NextAction.DEPLOY):
             count_dict[key] = len(method(next_action=next_action, sync=False))
         return count_dict
 
-    def get_solution_uuid(self, workload):
+    def get_solution_uuid(self, workload, identity_name=None):
         if workload.info.metadata:
             try:
                 metadata = j.data.serializers.json.loads(
-                    j.sals.reservation_chatflow.deployer.decrypt_metadata(workload.info.metadata)
+                    j.sals.reservation_chatflow.deployer.decrypt_metadata(workload.info.metadata, identity_name)
                 )
             except:
                 return
@@ -662,16 +665,20 @@ def _list_single_container_solution(self, chatflow, next_action=NextAction.DEPLO
                 result[-1]["wids"] += c_dict["vol_ids"]
         return result
 
-    def cancel_solution_by_uuid(self, solution_uuid):
+    def cancel_solution_by_uuid(self, solution_uuid, identity_name=None):
+        identity_name = identity_name or j.core.identity.me.instance_name
+        identity = j.core.identity.get(identity_name)
         # Get workloads with specific UUID
-        for workload in j.sals.zos.get().workloads.list(j.core.identity.me.tid, next_action="DEPLOY"):
-            if solution_uuid == self.get_solution_uuid(workload):
-                j.sals.zos.get().workloads.decomission(workload.id)
+        for workload in j.sals.zos.get(identity_name).workloads.list(identity.tid, next_action="DEPLOY"):
+            if solution_uuid == self.get_solution_uuid(workload, identity_name):
+                j.sals.zos.get(identity_name).workloads.decomission(workload.id)
 
-    def get_workloads_by_uuid(self, solution_uuid, next_action=None):
+    def get_workloads_by_uuid(self, solution_uuid, next_action=None, identity_name=None):
+        identity_name = identity_name or j.core.identity.me.instance_name
+        identity = j.core.identity.get(identity_name)
         workloads = []
-        for workload in j.sals.zos.get().workloads.list(j.core.identity.me.tid, next_action=next_action):
-            if solution_uuid == self.get_solution_uuid(workload):
+        for workload in j.sals.zos.get(identity_name).workloads.list(identity.tid, next_action=next_action):
+            if solution_uuid == self.get_solution_uuid(workload, identity_name):
                 workloads.append(workload)
         return workloads
 
diff --git a/jumpscale/sals/zos/pools.py b/jumpscale/sals/zos/pools.py
index 5b167c5ca2..292fe60e92 100644
--- a/jumpscale/sals/zos/pools.py
+++ b/jumpscale/sals/zos/pools.py
@@ -122,4 +122,4 @@ def list(self, page=None) -> List[Pool]:
           pool: list of pools
 
         """
-        return self._pools.list()
+        return self._pools.list(customer_tid=self._identity.tid)
diff --git a/jumpscale/servers/threebot/__init__.py b/jumpscale/servers/threebot/__init__.py
index 50cddebff7..1a8ca238b6 100644
--- a/jumpscale/servers/threebot/__init__.py
+++ b/jumpscale/servers/threebot/__init__.py
@@ -1,5 +1,6 @@
 from jumpscale.core.base import StoredFactory
 from jumpscale.sals.nginx.nginx import PORTS
+from jumpscale.entry_points.threebot import create_wallets_if_not_exists
 
 
 class ThreebotServerFactory(StoredFactory):
@@ -29,6 +30,7 @@ def start_default(self, wait=False, local=False, domain=None, email=None):
             server.domain = domain
             server.email = email
         server.save()
+        create_wallets_if_not_exists()
         server.start(wait=wait)
 
 
diff --git a/solutions_automation/deployer.py b/solutions_automation/deployer.py
index c6e4139b81..fc16ec0441 100644
--- a/solutions_automation/deployer.py
+++ b/solutions_automation/deployer.py
@@ -18,7 +18,9 @@
 from solutions_automation.marketplace.website import WebsiteAutomated
 from solutions_automation.marketplace.wiki import WikiAutomated
 from solutions_automation.threebot.deploy import ThreebotDeployAutomated
-from solutions_automation.threebot.extend import ThreebotExtendAutomated
+from solutions_automation.threebot.change_size import ThreebotChangeSizeAutomated
+from solutions_automation.threebot.start import ThreebotStart
+from solutions_automation.threebot.change_location import ThreebotChangeLocation
 
 
 def deploy_gitea(solution_name, wg_config="NO", debug=True):
@@ -372,6 +374,8 @@ def deploy_threebot(
     email_host="",
     email_host_password="",
     escalation_mail_address="",
+    node_policy="Automatic",
+    flavor="Silver (CPU 1 - Memory 2 GB - Disk 2 GB [SSD])",
 ):
     return ThreebotDeployAutomated(
         type="Create",
@@ -387,19 +391,18 @@ def deploy_threebot(
         email_host=email_host,
         email_host_password=email_host_password,
         escalation_mail_address=escalation_mail_address,
+        node_policy=node_policy,
+        flavor=flavor,
     )
 
 
-def recover_threebot(solution_name, recover_password, ssh, expiration, debug=True):
-    return ThreebotDeployAutomated(
-        type="Recover",
-        solution_name=solution_name,
-        recover_password=recover_password,
-        ssh=ssh,
-        expiration=expiration,
-        debug=debug,
-    )
+def start_threebot(name, password):
+    return ThreebotStart(tname=name, password=password,)
+
+
+def change_threebot_size(name, password, flavor="Silver (CPU 1 - Memory 2 GB - Disk 2 GB [SSD])"):
+    return ThreebotChangeSizeAutomated(tname=name, password=password, flavor=flavor)
 
 
-def extend_threebot(name, expiration):
-    return ThreebotExtendAutomated(name=name, expiration=expiration)
+def change_threebot_location(name, password):
+    return ThreebotChangeLocation(tname=name, password=password)
diff --git a/solutions_automation/threebot/change_location.py b/solutions_automation/threebot/change_location.py
new file mode 100644
index 0000000000..2d5813b2e1
--- /dev/null
+++ b/solutions_automation/threebot/change_location.py
@@ -0,0 +1,18 @@
+from textwrap import dedent
+
+from jumpscale.packages.threebot_deployer.chats.change_location import ThreebotRedeploy
+from solutions_automation.utils.gedispatch import GedisChatBotPatch
+
+
+class ThreebotChangeLocation(GedisChatBotPatch, ThreebotRedeploy):
+    PASSWORD = "Please enter the 3Bot password."
+    NODE_POLICY = "Please select the deployment location policy."
+    EXPIRATION = "Please enter the solution's expiration time"
+    QS = {
+        PASSWORD: "password",
+        NODE_POLICY: "node_policy",
+        EXPIRATION: "expiration",
+    }
+
+    def ask(self, msg, *args, **kwargs):
+        return self.fetch_param(msg["msg"], *args, **kwargs)
diff --git a/solutions_automation/threebot/change_size.py b/solutions_automation/threebot/change_size.py
new file mode 100644
index 0000000000..6d67f55371
--- /dev/null
+++ b/solutions_automation/threebot/change_size.py
@@ -0,0 +1,13 @@
+from jumpscale.packages.threebot_deployer.chats.change_size import ThreebotRedeploy
+from solutions_automation.utils.gedispatch import GedisChatBotPatch
+
+
+class ThreebotChangeSizeAutomated(GedisChatBotPatch, ThreebotRedeploy):
+    PASSWORD = "Please enter the 3Bot password."
+
+    QS = {
+        PASSWORD: "password",
+    }
+
+    def ask(self, msg, *args, **kwargs):
+        return self.fetch_param(msg["msg"], *args, **kwargs)
diff --git a/solutions_automation/threebot/deploy.py b/solutions_automation/threebot/deploy.py
index 2ed4986083..5916c4c1f7 100644
--- a/solutions_automation/threebot/deploy.py
+++ b/solutions_automation/threebot/deploy.py
@@ -5,7 +5,7 @@
 
 
 class ThreebotDeployAutomated(GedisChatBotPatch, ThreebotDeploy):
-    TYPE = "Would you like to create a new 3Bot instance, or recover an existing one?"
+    TYPE = "Would you like to create a new 3Bot instance,*?"
     NAME = "Just like humans, each 3Bot needs their own unique identity to exist on top of the Threefold Grid. Please enter a name for your new 3Bot. This name will be used as the web address that could give you access to your 3Bot anytime."
     RECOVER_NAME = "Please enter the 3Bot name you want to recover"
     SECRET = "Please create a secure password for your new 3Bot. This password is used to recover your hosted 3Bot."
@@ -17,6 +17,7 @@ class ThreebotDeployAutomated(GedisChatBotPatch, ThreebotDeploy):
     EMAIL_HOST_USER = "E-mail address for your solution"
     EMAIL_HOST = "SMTP host example: `smtp.gmail.com`"
     EMAIL_HOST_PASSWORD = "Host e-mail password"
+    NODE_POLICY = "Please select the deployment location policy."
     ESCALATION_MAIL_ADDRESS = "Email address to receive email notifications on"
     WIREGUARD = dedent(
         """
@@ -38,6 +39,7 @@ class ThreebotDeployAutomated(GedisChatBotPatch, ThreebotDeploy):
         EMAIL_HOST: "email_host",
         EMAIL_HOST_PASSWORD: "email_host_password",
         ESCALATION_MAIL_ADDRESS: "escalation_mail_address",
+        NODE_POLICY: "node_policy",
     }
 
     def ask(self, msg, *args, **kwargs):
diff --git a/solutions_automation/threebot/extend.py b/solutions_automation/threebot/extend.py
deleted file mode 100644
index d1f560f649..0000000000
--- a/solutions_automation/threebot/extend.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from jumpscale.packages.threebot_deployer.chats.extend import ExtendThreebot
-from solutions_automation.utils.gedispatch import GedisChatBotPatch
-
-
-class ThreebotExtendAutomated(GedisChatBotPatch, ExtendThreebot):
-    NAME = "Choose the 3Bot you would like to extend"
-    EXPIRATION = "Please enter the solution's expiration time"
-    QS = {
-        NAME: "name",
-        EXPIRATION: "expiration",
-    }
diff --git a/solutions_automation/threebot/start.py b/solutions_automation/threebot/start.py
new file mode 100644
index 0000000000..4e7eb4e649
--- /dev/null
+++ b/solutions_automation/threebot/start.py
@@ -0,0 +1,14 @@
+from textwrap import dedent
+
+from jumpscale.packages.threebot_deployer.chats.restart_threebot import ThreebotRedeploy
+from solutions_automation.utils.gedispatch import GedisChatBotPatch
+
+
+class ThreebotStart(GedisChatBotPatch, ThreebotRedeploy):
+    PASSWORD = "Please enter the 3Bot password."
+    QS = {
+        PASSWORD: "password",
+    }
+
+    def ask(self, msg, *args, **kwargs):
+        return self.fetch_param(msg["msg"], *args, **kwargs)
diff --git a/solutions_automation/utils/gedispatch.py b/solutions_automation/utils/gedispatch.py
index c795760d82..e2ad93fdaa 100644
--- a/solutions_automation/utils/gedispatch.py
+++ b/solutions_automation/utils/gedispatch.py
@@ -38,7 +38,7 @@ def __init__(self, **kwargs):
             setattr(self, k, v)
 
         self.name_qs = 0
-        super().__init__(spawn=False)
+        super().__init__(spawn=False, **kwargs)
 
     def get_name(self, msg, *args, **kwargs):
         if self.name_qs == 0:
diff --git a/tests/sals/automated_chatflows/test_threebot_deployer.py b/tests/sals/automated_chatflows/test_threebot_deployer.py
index 7b0c7f910e..7e2cdea2b3 100644
--- a/tests/sals/automated_chatflows/test_threebot_deployer.py
+++ b/tests/sals/automated_chatflows/test_threebot_deployer.py
@@ -4,6 +4,7 @@
 from jumpscale.loader import j
 from solutions_automation import deployer
 from tests.sals.automated_chatflows.chatflows_base import ChatflowsBase
+from jumpscale.packages.threebot_deployer.bottle.utils import stop_threebot_solution
 
 
 @pytest.mark.integration
@@ -14,6 +15,7 @@ def setUpClass(cls):
         # Accept admin T&C for testing identity.
         cls.accept_terms_conditions(type_="marketplace")
         cls.solution_uuid = ""
+        cls.secret = ""
 
     @classmethod
     def tearDownClass(cls):
@@ -22,9 +24,8 @@ def tearDownClass(cls):
         super().tearDownClass()
 
     def tearDown(self):
-        if self.solution_uuid:
-            j.sals.reservation_chatflow.solutions.cancel_solution_by_uuid(self.solution_uuid)
-        super().tearDown()
+        if self.solution_uuid and self.secret:
+            stop_threebot_solution(self.tname, self.solution_uuid, self.secret)
 
     def test01_deploy_threebot(self):
         """Test case for deploying a threebot.
@@ -35,62 +36,88 @@ def test01_deploy_threebot(self):
         """
         self.info("Deploy a threebot")
         name = self.random_name()
-        secret = self.random_name()
-        threebot = deployer.deploy_threebot(solution_name=name, secret=secret, expiration=time() + 60 * 15, ssh="")
+        self.secret = self.random_name()
+        threebot = deployer.deploy_threebot(solution_name=name, secret=self.secret, expiration=time() + 60 * 15, ssh="")
         self.solution_uuid = threebot.solution_id
 
         self.info("Check that threebot is reachable.")
         request = j.tools.http.get(f"http://{threebot.domain}", verify=False, timeout=self.timeout)
         self.assertEqual(request.status_code, 200)
 
-    def test02_recover_threebot(self):
-        """Test case for recovering a threebot.
+    def test02_start_threebot(self):
+        """Test case for starting a threebot.
 
         **Test Scenario**
-        - Deploy a threebot.
-        - Delete the threebot has been deployed.
-        - Recover the threebot has been deleted.
-        - Check that the threebot has been recovered is reachable.
+        - Deploy a threebot
+        - Stop the deployed threebot
+        - Start the stopped threebot.
+        - Check that threebot is reachable.
         """
-        self.info("Deploy a threebot.")
+        self.info("Deploy a threebot")
         name = self.random_name()
-        secret = self.random_name()
-        threebot = deployer.deploy_threebot(solution_name=name, secret=secret, expiration=time() + 60 * 15, ssh="")
+        self.secret = self.random_name()
+        threebot = deployer.deploy_threebot(solution_name=name, secret=self.secret, expiration=time() + 60 * 15, ssh="")
+        self.solution_uuid = threebot.solution_id
 
-        self.info("Delete the threebot has been deployed.")
-        j.sals.reservation_chatflow.solutions.cancel_solution_by_uuid(threebot.solution_id)
+        self.info("Stop the deployed threebot")
+        stop_threebot_solution(self.tname, self.solution_uuid, self.secret)
 
-        self.info("Recover the threebot has been deleted.")
-        threebot = deployer.recover_threebot(
-            solution_name=name, recover_password=secret, ssh=self.ssh_cl.public_key_path, expiration=time() + 60 * 15,
-        )
+        self.info("Start the stopped threebot")
+        threebot = deployer.start_threebot(name, self.secret)
         self.solution_uuid = threebot.solution_id
 
-        self.info("Check that the threebot has been recovered is reachable.")
+        self.info("Check that threebot is reachable.")
         request = j.tools.http.get(f"http://{threebot.domain}", verify=False, timeout=self.timeout)
         self.assertEqual(request.status_code, 200)
 
-    def test03_extend_threebot(self):
-        """Test case for extending a threebot.
+    def test03_change_threebot_size(self):
+        """Test case for starting a threebot.
 
         **Test Scenario**
-        - Deploy a threebot.
-        - Extend the threebot has been deployed.
-        - Check that the expiration is increased with the extending time.
+        - Deploy a threebot
+        - Stop the deployed threebot
+        - Change the stopped threebot size.
+        - Check that threebot is reachable.
         """
-        self.info("Deploy a threebot.")
+        self.info("Deploy a threebot")
         name = self.random_name()
-        secret = self.random_name()
-        now = time()
-        expiration = 60 * 15
-        threebot = deployer.deploy_threebot(solution_name=name, secret=secret, expiration=now + expiration, ssh="")
-
-        self.info("Extend the threebot has been deployed.")
-        threebot_expire = threebot.pool.empty_at
-        extend_threebot = deployer.extend_threebot(name=name, expiration=threebot_expire + expiration)
+        self.secret = self.random_name()
+        threebot = deployer.deploy_threebot(solution_name=name, secret=self.secret, expiration=time() + 60 * 15, ssh="")
         self.solution_uuid = threebot.solution_id
 
-        self.info("Check that the expiration is increased with the extending time.")
-        new_expire = extend_threebot.pool.empty_at
-        calculated_expire = threebot_expire + expiration
-        self.assertAlmostEqual(new_expire, calculated_expire, delta=100)
+        self.info("Stop the deployed threebot")
+        stop_threebot_solution(self.tname, self.solution_uuid, self.secret)
+
+        self.info("Start the stopped threebot")
+        threebot = deployer.change_threebot_size(name, self.secret)
+        self.solution_uuid = threebot.solution_id
+
+        self.info("Check that threebot is reachable.")
+        request = j.tools.http.get(f"http://{threebot.domain}", verify=False, timeout=self.timeout)
+        self.assertEqual(request.status_code, 200)
+
+    def test04_change_threebot_location(self):
+        """Test case for starting a threebot.
+
+        **Test Scenario**
+        - Deploy a threebot
+        - Stop the deployed threebot
+        - Change the stopped threebot location.
+        - Check that threebot is reachable.
+        """
+        self.info("Deploy a threebot")
+        name = self.random_name()
+        self.secret = self.random_name()
+        threebot = deployer.deploy_threebot(solution_name=name, secret=self.secret, expiration=time() + 60 * 15, ssh="")
+        self.solution_uuid = threebot.solution_id
+
+        self.info("Stop the deployed threebot")
+        stop_threebot_solution(self.tname, self.solution_uuid, self.secret)
+
+        self.info("Start the stopped threebot")
+        threebot = deployer.change_threebot_location(name, self.secret)
+        self.solution_uuid = threebot.solution_id
+
+        self.info("Check that threebot is reachable.")
+        request = j.tools.http.get(f"http://{threebot.domain}", verify=False, timeout=self.timeout)
+        self.assertEqual(request.status_code, 200)