diff --git a/.eslintrc.cjs b/.eslintrc.cjs
index 9f950f6f..ec5fbe65 100644
--- a/.eslintrc.cjs
+++ b/.eslintrc.cjs
@@ -7,7 +7,7 @@ module.exports = {
   },
   extends: [
     "eslint:recommended",
-    "plugin:vue/vue3-recommended",
+    "plugin:vue/recommended",
     "plugin:vuetify/recommended",
     "plugin:nuxt/recommended",
   ],
diff --git a/components/FeedBack/Snackers.vue b/components/FeedBack/Snackers.vue
index 881e7752..a1343f85 100644
--- a/components/FeedBack/Snackers.vue
+++ b/components/FeedBack/Snackers.vue
@@ -51,7 +51,7 @@
           variant="flat"
           size="20"
           :color="feedback.type"
-          @click="feedback_store.delete_feedback(index)"
+          @click="feedback_store.delete_feedback(feedback.id)"
         >
           <v-icon icon="mdi-close" size="20" color="white" />
         </v-btn>
diff --git a/components/Launcher.vue b/components/Launcher.vue
index e2ca1464..259bbe93 100644
--- a/components/Launcher.vue
+++ b/components/Launcher.vue
@@ -2,7 +2,7 @@
   <v-container class="justify">
     <v-row align-content="center" align="center">
       <v-col
-        v-if="!is_captcha_validated"
+        v-if="!infra_store.is_captcha_validated"
         class="align"
         cols="12"
         align-self="center"
@@ -11,7 +11,7 @@
         <h4 class="pb-3">Please complete the recaptcha to launch the app</h4>
         <Recaptcha :site_key="site_key" />
       </v-col>
-      <v-col v-else-if="!is_running && is_connexion_launched">
+      <v-col v-else-if="infra_store.status == Status.CREATING">
         <Loading />
       </v-col>
     </v-row>
@@ -19,17 +19,17 @@
 </template>
 
 <script setup>
-  const viewer_store = use_viewer_store()
-  const infra_store = use_infra_store()
-  const { is_captcha_validated, is_connexion_launched, is_running } =
-    storeToRefs(infra_store)
+  import Status from "@/utils/status.js"
 
+  const infra_store = use_infra_store()
   const site_key = useRuntimeConfig().public.RECAPTCHA_SITE_KEY
 
-  watch(is_captcha_validated, async (value) => {
-    if (value === true && process.client) {
-      await infra_store.create_connexion()
-      await viewer_store.ws_connect()
-    }
-  })
+  watch(
+    () => infra_store.is_captcha_validated,
+    (value, oldValue) => {
+      if (value && !oldValue && process.client) {
+        infra_store.create_backend()
+      }
+    },
+  )
 </script>
diff --git a/components/Loading.vue b/components/Loading.vue
index 601845b1..a486e2f3 100644
--- a/components/Loading.vue
+++ b/components/Loading.vue
@@ -3,14 +3,14 @@
     <v-col cols="12" class="ma-3">
       <v-card loading>
         <v-card-title class="text-center">
-          Cloud instance is starting...
+          Microservices are starting...
         </v-card-title>
         <v-card-subtitle class="text-center">
           Why do you have to wait?
         </v-card-subtitle>
         <v-card-text class="text-center">
-          We start our server only on demand... and this takes a few minutes
-          before you can use our free app.
+          We start our microservices only on demand... and this takes a few
+          minutes before you can use our free app.
           <br />
           This is aligned with our energy sobriety policy. So be patient
           <v-icon color="primary" size="20">
diff --git a/components/PackagesVersions.vue b/components/PackagesVersions.vue
index f56a50c1..4cefe1bf 100644
--- a/components/PackagesVersions.vue
+++ b/components/PackagesVersions.vue
@@ -19,14 +19,13 @@
 </template>
 
 <script setup>
-  const infra_store = use_infra_store()
-  const { is_running } = storeToRefs(infra_store)
+  import Status from "@/utils/status.js"
 
   const props = defineProps({
     schema: { type: Object, required: true },
   })
-  const { schema } = props
 
+  const geode_store = use_geode_store()
   const packages_versions = ref([])
 
   async function get_packages_versions() {
@@ -34,7 +33,7 @@
 
     const promise = new Promise((resolve, reject) => {
       api_fetch(
-        { schema },
+        { schema: props.schema },
         {
           request_error_function: () => {
             reject()
@@ -53,9 +52,12 @@
     await Promise.all(array_promise)
   }
 
-  watch(is_running, () => {
-    get_packages_versions()
-  })
+  watch(
+    () => geode_store.status,
+    (value) => {
+      if (value == Status.CONNECTED) get_packages_versions()
+    },
+  )
 
   await get_packages_versions()
 </script>
diff --git a/components/Recaptcha.vue b/components/Recaptcha.vue
index a2796666..0c4902d4 100644
--- a/components/Recaptcha.vue
+++ b/components/Recaptcha.vue
@@ -2,10 +2,10 @@
   <ClientOnly>
     <vue-recaptcha
       ref="recaptcha"
-      :sitekey="site_key"
+      :sitekey="props.site_key"
       :load-recaptcha-script="true"
       align-self="center"
-      @expired="is_captcha_validated = false"
+      @expired="infra_store.is_captcha_validated = false"
       @verify="submit_recaptcha"
     />
   </ClientOnly>
@@ -14,12 +14,10 @@
 <script setup>
   import { VueRecaptcha } from "vue-recaptcha"
   const infra_store = use_infra_store()
-  const { is_captcha_validated } = storeToRefs(infra_store)
 
   const props = defineProps({
     site_key: { type: String, required: true },
   })
-  const { site_key } = props
 
   onMounted(() => {
     if (process.client) {
diff --git a/components/RemoteRenderingView.vue b/components/RemoteRenderingView.vue
index ab7a8315..04f599e9 100644
--- a/components/RemoteRenderingView.vue
+++ b/components/RemoteRenderingView.vue
@@ -14,7 +14,7 @@
         "
         class="pa-0"
         @click="get_x_y"
-        @keydown.esc="app_store.toggle_picking_mode(false)"
+        @keydown.esc="viewer_store.toggle_picking_mode(false)"
       />
     </div>
   </ClientOnly>
@@ -24,17 +24,20 @@
   import vtkRemoteView from "@kitware/vtk.js/Rendering/Misc/RemoteView"
   import { useElementSize, useWindowSize } from "@vueuse/core"
   import viewer_schemas from "@geode/opengeodeweb-viewer/schemas.json"
+  import Status from "@/utils/status.js"
 
-  const viewer_store = use_viewer_store()
-  const { client, is_running, picking_mode } = storeToRefs(viewer_store)
+  const props = defineProps({
+    viewId: { type: String, default: "-1" },
+  })
 
-  const viewer = ref(null)
+  const viewer_store = use_viewer_store()
+  const viewer = useTemplateRef("viewer")
   const { width, height } = useElementSize(viewer)
 
   const { width: windowWidth, height: windowHeight } = useWindowSize()
 
   function get_x_y(event) {
-    if (picking_mode.value === true) {
+    if (viewer_store.picking_mode.value === true) {
       const { offsetX, offsetY } = event
       viewer_store.set_picked_point(offsetX, offsetY)
       viewer_call({
@@ -44,13 +47,7 @@
     }
   }
 
-  const props = defineProps({
-    viewId: { type: String, default: "-1" },
-  })
-
-  const { viewId } = toRefs(props)
   const connected = ref(false)
-
   const view = vtkRemoteView.newInstance({
     rpcWheelEvent: "viewport.mouse.zoom.wheel",
   })
@@ -70,33 +67,42 @@
     resize()
   })
 
-  watch(picking_mode, (value) => {
-    const cursor = value ? "crosshair" : "pointer"
-    view.getCanvasView().setCursor(cursor)
-  })
+  watch(
+    () => viewer_store.picking_mode,
+    (value) => {
+      const cursor = value ? "crosshair" : "pointer"
+      view.getCanvasView().setCursor(cursor)
+    },
+  )
 
   watch([width, height], () => {
     resize()
   })
 
-  watch(client, () => {
-    connect()
-  })
-
-  watch(viewId, (id) => {
-    if (connected.value) {
-      view.setViewId(id)
-      view.render()
-    }
-  })
+  watch(
+    () => viewer_store.client,
+    () => {
+      connect()
+    },
+  )
+
+  watch(
+    () => props.viewId,
+    (id) => {
+      if (connected.value) {
+        view.setViewId(id)
+        view.render()
+      }
+    },
+  )
 
   function connect() {
-    if (!is_running.value) {
+    if (viewer_store.status !== Status.CONNECTED) {
       return
     }
-    const session = client.value.getConnection().getSession()
+    const session = viewer_store.client.getConnection().getSession()
     view.setSession(session)
-    view.setViewId(viewId.value)
+    view.setViewId(props.viewId)
     connected.value = true
     view.render()
   }
diff --git a/components/Wrapper.vue b/components/Wrapper.vue
index aaf4fc74..2d010d88 100644
--- a/components/Wrapper.vue
+++ b/components/Wrapper.vue
@@ -1,22 +1,23 @@
 <template>
   <v-container>
     <v-row class="flex-column">
-      <v-col v-if="!is_running">
-        <Launcher />
-      </v-col>
-      <v-col v-if="is_running">
-        <Stepper />
-      </v-col>
-      <v-col v-if="is_running">
-        <PackagesVersions :schema="versions_schema" />
-      </v-col>
+      <template v-if="!infra_store.microservices_connected">
+        <v-col>
+          <Launcher />
+        </v-col>
+      </template>
+      <template v-else>
+        <v-col>
+          <Stepper />
+        </v-col>
+        <v-col> <PackagesVersions :schema="versions_schema" /> </v-col>
+      </template>
     </v-row>
   </v-container>
 </template>
 
 <script setup>
   const infra_store = use_infra_store()
-  const { is_running } = storeToRefs(infra_store)
 
   const props = defineProps({
     versions_schema: { type: Object, required: true },
diff --git a/composables/run_function_when_infra_running.js b/composables/run_function_when_infra_running.js
deleted file mode 100644
index 00686ea5..00000000
--- a/composables/run_function_when_infra_running.js
+++ /dev/null
@@ -1,15 +0,0 @@
-export function run_function_when_infra_running(function_to_run) {
-  const infra_store = use_infra_store()
-  const { is_running } = storeToRefs(infra_store)
-  if (is_running.value) {
-    function_to_run()
-  } else {
-    watch(is_running, (value) => {
-      if (value) {
-        function_to_run()
-      }
-    })
-  }
-}
-
-export default run_function_when_infra_running
diff --git a/composables/run_function_when_microservices_connected.js b/composables/run_function_when_microservices_connected.js
new file mode 100644
index 00000000..98aea2d6
--- /dev/null
+++ b/composables/run_function_when_microservices_connected.js
@@ -0,0 +1,15 @@
+export function run_function_when_microservices_connected(function_to_run) {
+  const infra_store = use_infra_store()
+  const { microservices_connected } = storeToRefs(infra_store)
+  if (microservices_connected.value) {
+    function_to_run()
+  } else {
+    watch(microservices_connected, (value) => {
+      if (value) {
+        function_to_run()
+      }
+    })
+  }
+}
+
+export default run_function_when_microservices_connected
diff --git a/nuxt.config.js b/nuxt.config.js
index d50843a1..20835cd1 100644
--- a/nuxt.config.js
+++ b/nuxt.config.js
@@ -39,6 +39,7 @@ export default defineNuxtConfig({
         "ajv",
         "fast-deep-equal",
         "globalthis",
+        "h3",
         "is-electron",
         "js-file-download",
         "lodash",
diff --git a/package.json b/package.json
index ab1acdb4..dca5f599 100644
--- a/package.json
+++ b/package.json
@@ -10,13 +10,14 @@
     "@nuxt/test-utils": "^3.15.1",
     "@pinia/testing": "^0.1.7",
     "@vitejs/plugin-vue": "^5.2.1",
+    "@vitest/coverage-v8": "^3.0.8",
     "@vue/test-utils": "^2.4.6",
     "eslint": "^8.57.0",
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-nuxt": "^4.0.0",
     "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-prettier-vue": "^5.0.0",
-    "eslint-plugin-vue": "^9.26.0",
+    "eslint-plugin-vue": "^9.33.0",
     "eslint-plugin-vuetify": "^2.4.0",
     "happy-dom": "^15.11.7",
     "jsdom": "^24.1.3",
@@ -53,6 +54,7 @@
     "pinia": "^2.2.2",
     "sass": "^1.77.8",
     "semver": "^7.6.3",
+    "uuid": "^11.1.0",
     "vue-recaptcha": "^2.0.3",
     "vue3-carousel": "^0.3.3"
   },
diff --git a/stores/feedback.js b/stores/feedback.js
index c54e019b..c8f2d8a3 100644
--- a/stores/feedback.js
+++ b/stores/feedback.js
@@ -1,26 +1,41 @@
+import { v4 as uuidv4 } from "uuid"
+
 export const use_feedback_store = defineStore("feedback", {
   state: () => ({
     feedbacks: [],
     server_error: false,
+    feedbacks_timeout_miliseconds: 5000,
   }),
   actions: {
     async add_error(code, route, name, description) {
+      const feedbackId = uuidv4()
       await this.feedbacks.push({
+        id: feedbackId,
         type: "error",
         code,
         route,
         name,
         description,
       })
+      setTimeout(() => {
+        this.delete_feedback(feedbackId)
+      }, this.feedbacks_timeout_miliseconds)
     },
     async add_success(description) {
+      const feedbackId = uuidv4()
       await this.feedbacks.push({
+        id: feedbackId,
         type: "success",
         description,
       })
+      setTimeout(() => {
+        this.delete_feedback(feedbackId)
+      }, this.feedbacks_timeout_miliseconds)
     },
-    async delete_feedback(feedback_index) {
-      await this.feedbacks.splice(feedback_index, 1)
+    async delete_feedback(feedbackId) {
+      this.feedbacks = this.feedbacks.filter(
+        (feedback) => feedback.id !== feedbackId,
+      )
     },
     async delete_server_error() {
       this.server_error = false
diff --git a/stores/geode.js b/stores/geode.js
index e4b1c813..63bf32bf 100644
--- a/stores/geode.js
+++ b/stores/geode.js
@@ -1,10 +1,11 @@
 import back_schemas from "@geode/opengeodeweb-back/schemas.json"
+import Status from "@/utils/status.js"
 
 export const use_geode_store = defineStore("geode", {
   state: () => ({
     default_local_port: "5000",
     request_counter: 0,
-    is_running: false,
+    status: Status.NOT_CONNECTED,
   }),
   getters: {
     protocol() {
@@ -37,7 +38,7 @@ export const use_geode_store = defineStore("geode", {
   actions: {
     ping_task() {
       setInterval(() => {
-        if (this.is_running) {
+        if (this.status == Status.CONNECTED) {
           this.do_ping()
         }
       }, 10 * 1000)
@@ -48,19 +49,20 @@ export const use_geode_store = defineStore("geode", {
       return useFetch(back_schemas.opengeodeweb_back.ping.$id, {
         baseURL: this.base_url,
         method: back_schemas.opengeodeweb_back.ping.methods[0],
+        body: {},
         onRequestError({ error }) {
           feedback_store.server_error = true
-          geode_store.is_running = false
+          geode_store.status = Status.NOT_CONNECTED
         },
         onResponse({ response }) {
           if (response.ok) {
             feedback_store.server_error = false
-            geode_store.is_running = true
+            geode_store.status = Status.CONNECTED
           }
         },
         onResponseError({ response }) {
           feedback_store.server_error = true
-          geode_store.is_running = false
+          geode_store.status = Status.NOT_CONNECTED
         },
       })
     },
@@ -71,4 +73,7 @@ export const use_geode_store = defineStore("geode", {
       this.request_counter--
     },
   },
+  share: {
+    omit: ["status"],
+  },
 })
diff --git a/stores/infra.js b/stores/infra.js
index da32c5db..b6395874 100644
--- a/stores/infra.js
+++ b/stores/infra.js
@@ -1,11 +1,12 @@
 import { useStorage } from "@vueuse/core"
 import isElectron from "is-electron"
+import Status from "@/utils/status.js"
 
 export const use_infra_store = defineStore("infra", {
   state: () => ({
     ID: useStorage("ID", ""),
     is_captcha_validated: false,
-    is_connexion_launched: false,
+    status: Status.NOT_CREATED,
   }),
   getters: {
     is_cloud() {
@@ -34,47 +35,53 @@ export const use_infra_store = defineStore("infra", {
         "/createbackend"
       return url
     },
-    is_running() {
-      return use_geode_store().is_running && use_viewer_store().is_running
+    microservices_connected() {
+      return (
+        use_geode_store().status == Status.CONNECTED &&
+        use_viewer_store().status == Status.CONNECTED
+      )
     },
-    is_busy() {
+    microservices_busy() {
       return use_geode_store().is_busy || use_viewer_store().is_busy
     },
   },
   actions: {
-    async create_connexion() {
-      if (this.is_connexion_launched) {
-        return
-      }
-      this.is_connexion_launched = true
-      return this.create_backend()
-    },
     async create_backend() {
-      const geode_store = use_geode_store()
-      const viewer_store = use_viewer_store()
-      const feedback_store = use_feedback_store()
-
-      if (isElectron()) {
-        const back_port = await window.electronAPI.run_back(geode_store.port)
-        geode_store.$patch({ default_local_port: back_port })
-        const viewer_port = await window.electronAPI.run_viewer(
-          viewer_store.port,
-        )
-        viewer_store.$patch({ default_local_port: viewer_port })
-      } else {
-        const { data, error } = await useFetch(this.lambda_url, {
-          method: "POST",
-        })
-        if (data.value !== null) {
+      if (this.status === Status.CREATED) return
+      navigator.locks.request("infra.create_backend", async (lock) => {
+        this.status = Status.CREATING
+        if (this.status === Status.CREATED) return
+        console.log("LOCK GRANTED !", lock)
+        const geode_store = use_geode_store()
+        const viewer_store = use_viewer_store()
+        const feedback_store = use_feedback_store()
+        if (isElectron()) {
+          const back_port = await window.electronAPI.run_back(geode_store.port)
+          geode_store.$patch({ default_local_port: back_port })
+          const viewer_port = await window.electronAPI.run_viewer(
+            viewer_store.port,
+          )
+          viewer_store.$patch({ default_local_port: viewer_port })
+        } else {
+          const { data, error } = await useFetch(this.lambda_url, {
+            method: "POST",
+          })
+          if (error.value || !data.value) {
+            this.status = Status.NOT_CREATED
+            feedback_store.server_error = true
+            return
+          }
           this.ID = data.value.ID
           localStorage.setItem("ID", data.value.ID)
-        } else {
-          feedback_store.server_error = true
-          return
         }
-      }
-      geode_store.$patch({ is_running: true })
-      return geode_store.ping_task()
+        this.status = Status.CREATED
+        return this.create_connection()
+      })
+    },
+    async create_connection() {
+      await use_viewer_store().ws_connect()
+      await use_geode_store().do_ping()
+      return
     },
   },
 })
diff --git a/stores/viewer.js b/stores/viewer.js
index 40ebb2c3..350736c5 100644
--- a/stores/viewer.js
+++ b/stores/viewer.js
@@ -2,16 +2,17 @@ import _ from "lodash"
 import vtkWSLinkClient from "@kitware/vtk.js/IO/Core/WSLinkClient"
 import "@kitware/vtk.js/Rendering/OpenGL/Profiles/Geometry"
 import schemas from "@geode/opengeodeweb-viewer/schemas.json"
+import Status from "@/utils/status.js"
 
 export const use_viewer_store = defineStore("viewer", {
   state: () => ({
     default_local_port: "1234",
     client: {},
     config: null,
-    is_running: false,
     picking_mode: false,
     picked_point: { x: null, y: null },
     request_counter: 0,
+    status: Status.NOT_CONNECTED,
   }),
   getters: {
     protocol() {
@@ -56,70 +57,76 @@ export const use_viewer_store = defineStore("viewer", {
       this.picking_mode = false
     },
     async ws_connect() {
-      if (process.env.NODE_ENV == "test") {
-        return
-      }
-      const SmartConnect = await import("wslink/src/SmartConnect")
-      vtkWSLinkClient.setSmartConnectClass(SmartConnect)
+      if (process.env.NODE_ENV == "test") return
+      if (this.status === Status.CONNECTED) return
+      navigator.locks.request("viewer.ws_connect", async (lock) => {
+        if (this.status === Status.CONNECTED) return
+        console.log("VIEWER LOCK GRANTED !", lock)
+        this.status = Status.CONNECTING
+        const SmartConnect = await import("wslink/src/SmartConnect")
+        vtkWSLinkClient.setSmartConnectClass(SmartConnect)
 
-      const config = { application: "Viewer" }
-      config.sessionURL = this.base_url
+        const config = { application: "Viewer" }
+        config.sessionURL = this.base_url
 
-      const { client } = this
-      if (this.is_running && client.isConnected()) {
-        client.disconnect(-1)
-        this.is_running = false
-      }
-      let clientToConnect = client
-      if (_.isEmpty(clientToConnect)) {
-        clientToConnect = vtkWSLinkClient.newInstance()
-      }
+        const { client } = this
+        if (this.status === Status.CONNECTED && client.isConnected()) {
+          client.disconnect(-1)
+          this.status = Status.NOT_CONNECTED
+        }
+        let clientToConnect = client
+        if (_.isEmpty(clientToConnect)) {
+          clientToConnect = vtkWSLinkClient.newInstance()
+        }
 
-      // Connect to busy store
-      clientToConnect.onBusyChange((count) => {
-        this.buzy = count
-      })
-      clientToConnect.beginBusy()
+        // Connect to busy store
+        clientToConnect.onBusyChange((count) => {
+          this.buzy = count
+        })
+        clientToConnect.beginBusy()
 
-      // Error
-      clientToConnect.onConnectionError((httpReq) => {
-        const message =
-          (httpReq && httpReq.response && httpReq.response.error) ||
-          `Connection error`
-        console.error(message)
-      })
+        // Error
+        clientToConnect.onConnectionError((httpReq) => {
+          const message =
+            (httpReq && httpReq.response && httpReq.response.error) ||
+            `Connection error`
+          console.error(message)
+        })
 
-      // Close
-      clientToConnect.onConnectionClose((httpReq) => {
-        const message =
-          (httpReq && httpReq.response && httpReq.response.error) ||
-          `Connection close`
-        console.error(message)
-      })
+        // Close
+        clientToConnect.onConnectionClose((httpReq) => {
+          const message =
+            (httpReq && httpReq.response && httpReq.response.error) ||
+            `Connection close`
+          console.error(message)
+        })
 
-      // Connect
-      const { connectImageStream } = await import(
-        "@kitware/vtk.js/Rendering/Misc/RemoteView"
-      )
-      return new Promise((resolve, reject) => {
-        clientToConnect
-          .connect(config)
-          .then((validClient) => {
-            connectImageStream(validClient.getConnection().getSession())
-            this.client = validClient
-            clientToConnect.endBusy()
+        // Connect
+        const { connectImageStream } = await import(
+          "@kitware/vtk.js/Rendering/Misc/RemoteView"
+        )
+        const viewer_store = this
+        return new Promise((resolve, reject) => {
+          clientToConnect
+            .connect(config)
+            .then((validClient) => {
+              connectImageStream(validClient.getConnection().getSession())
+              viewer_store.client = validClient
+              clientToConnect.endBusy()
 
-            // Now that the client is ready let's setup the server for us
-            viewer_call({
-              schema: schemas.opengeodeweb_viewer.viewer.reset_visualization,
+              // Now that the client is ready let's setup the server for us
+              viewer_call({
+                schema: schemas.opengeodeweb_viewer.viewer.reset_visualization,
+              })
+              viewer_store.status = Status.CONNECTED
+              resolve()
             })
-            this.is_running = true
-            resolve()
-          })
-          .catch((error) => {
-            console.error(error)
-            reject(error)
-          })
+            .catch((error) => {
+              console.error(error)
+              viewer_store.status = Status.NOT_CONNECTED
+              reject(error)
+            })
+        })
       })
     },
     start_request() {
@@ -129,4 +136,7 @@ export const use_viewer_store = defineStore("viewer", {
       this.request_counter--
     },
   },
+  share: {
+    omit: ["status", "client"],
+  },
 })
diff --git a/test/components/FileSelector.nuxt.test.js b/test/components/FileSelector.nuxt.test.js
index fb5a4992..04ca171c 100644
--- a/test/components/FileSelector.nuxt.test.js
+++ b/test/components/FileSelector.nuxt.test.js
@@ -123,7 +123,6 @@ describe("FileSelector.vue", async () => {
       await flushPromises()
 
       const file_uploader = wrapper.findComponent(FileUploader)
-      console.log("wrapper", wrapper)
       expect(wrapper.vm.props.files).toEqual(files)
       const upload_files = vi.spyOn(file_uploader.vm, "upload_files")
       expect(upload_files).not.toHaveBeenCalled()
diff --git a/test/components/Launcher.nuxt.test.js b/test/components/Launcher.nuxt.test.js
index b2f4e2fb..7cde6da1 100644
--- a/test/components/Launcher.nuxt.test.js
+++ b/test/components/Launcher.nuxt.test.js
@@ -1,38 +1,47 @@
-// // @vitest-environment nuxt
-
-// import { describe, expect, test, vi } from "vitest"
-// import { flushPromises } from "@vue/test-utils"
-// import { mountSuspended } from "@nuxt/test-utils/runtime"
-
-// import { createVuetify } from "vuetify"
-// import * as components from "vuetify/components"
-// import * as directives from "vuetify/directives"
-
-// import Launcher from "@/components/Launcher.vue"
-
-// const vuetify = createVuetify({
-//   components,
-//   directives,
-// })
-
-// const infra_store = use_infra_store()
-
-// global.ResizeObserver = require("resize-observer-polyfill")
-
-// describe("Launcher.vue", async () => {
-//   test(`Mount`, async () => {
-//     const spy_infra_store = vi.spyOn(infra_store, "create_connexion")
-//     const wrapper = await mountSuspended(Launcher, {
-//       global: {
-//         plugins: [vuetify],
-//       },
-//     })
-//     expect(wrapper.exists()).toBe(true)
-//     await infra_store.$patch({ is_captcha_validated: true })
-//     flushPromises()
-//     expect(spy_infra_store).toHaveBeenCalled()
-//   })
-// })
-describe("Fake", async () => {
-  test(`Fake`, async () => {})
+// @vitest-environment nuxt
+
+import { describe, expect, test, vi } from "vitest"
+import { flushPromises } from "@vue/test-utils"
+import { mountSuspended } from "@nuxt/test-utils/runtime"
+
+import { createVuetify } from "vuetify"
+import * as components from "vuetify/components"
+import * as directives from "vuetify/directives"
+
+import Launcher from "@/components/Launcher.vue"
+
+const vuetify = createVuetify({
+  components,
+  directives,
+})
+
+const infra_store = use_infra_store()
+
+// Mock navigator.locks API
+const mockLockRequest = vi.fn().mockImplementation(async (name, callback) => {
+  return callback({ name })
+})
+
+vi.stubGlobal("navigator", {
+  ...navigator,
+  locks: {
+    request: mockLockRequest,
+  },
+})
+
+global.ResizeObserver = require("resize-observer-polyfill")
+
+describe("Launcher.vue", async () => {
+  test(`Mount`, async () => {
+    const spy_infra_store = vi.spyOn(infra_store, "create_backend")
+    const wrapper = await mountSuspended(Launcher, {
+      global: {
+        plugins: [vuetify],
+      },
+    })
+    expect(wrapper.exists()).toBe(true)
+    await infra_store.$patch({ is_captcha_validated: true })
+    flushPromises()
+    expect(spy_infra_store).toHaveBeenCalled()
+  })
 })
diff --git a/test/composables/run_function_when_infra_running.nuxt.test.js b/test/composables/run_function_when_infra_running.nuxt.test.js
deleted file mode 100644
index 6831eac7..00000000
--- a/test/composables/run_function_when_infra_running.nuxt.test.js
+++ /dev/null
@@ -1,30 +0,0 @@
-import { describe, expect, test, beforeEach, vi } from "vitest"
-
-describe("run_function_when_infra_running", () => {
-  const geode_store = use_geode_store()
-  const viewer_store = use_viewer_store()
-
-  const dumb_obj = { dumb_method: () => true }
-
-  beforeEach(async () => {
-    await geode_store.$patch({ is_running: false })
-    await viewer_store.$patch({ is_running: false })
-  })
-
-  test("is_running true", async () => {
-    const spy = vi.spyOn(dumb_obj, "dumb_method")
-    await geode_store.$patch({ is_running: true })
-    await viewer_store.$patch({ is_running: true })
-
-    await run_function_when_infra_running(dumb_obj.dumb_method)
-    expect(spy).toHaveBeenCalled()
-  })
-
-  test("is_running false", async () => {
-    const spy = vi.spyOn(dumb_obj, "dumb_method")
-    run_function_when_infra_running(dumb_obj.dumb_method)
-    await geode_store.$patch({ is_running: true })
-    await viewer_store.$patch({ is_running: true })
-    expect(spy).toHaveBeenCalled()
-  })
-})
diff --git a/test/composables/run_function_when_microservices_connected.test.js b/test/composables/run_function_when_microservices_connected.test.js
new file mode 100644
index 00000000..f100d0d5
--- /dev/null
+++ b/test/composables/run_function_when_microservices_connected.test.js
@@ -0,0 +1,30 @@
+import { describe, expect, test, beforeEach, vi } from "vitest"
+import Status from "@/utils/status.js"
+
+describe("run_function_when_microservices_connected", () => {
+  const geode_store = use_geode_store()
+  const viewer_store = use_viewer_store()
+
+  const dumb_obj = { dumb_method: () => true }
+
+  beforeEach(async () => {
+    await geode_store.$patch({ status: Status.NOT_CONNECTED })
+    await viewer_store.$patch({ status: Status.NOT_CONNECTED })
+  })
+  console.log("Status.CONNECTED", Status.CONNECTED)
+  test("microservices connected", async () => {
+    const spy = vi.spyOn(dumb_obj, "dumb_method")
+    run_function_when_microservices_connected(dumb_obj.dumb_method)
+    await geode_store.$patch({ status: Status.CONNECTED })
+    await viewer_store.$patch({ status: Status.CONNECTED })
+    expect(spy).toHaveBeenCalled()
+  })
+
+  test("microservices not connected", async () => {
+    const spy = vi.spyOn(dumb_obj, "dumb_method")
+    run_function_when_microservices_connected(dumb_obj.dumb_method)
+    await geode_store.$patch({ status: Status.NOT_CONNECTED })
+    await viewer_store.$patch({ status: Status.NOT_CONNECTED })
+    expect(spy).not.toHaveBeenCalled()
+  })
+})
diff --git a/test/stores/Feedback.nuxt.test.js b/test/stores/Feedback.nuxt.test.js
index fb5fc90b..2570dbf6 100644
--- a/test/stores/Feedback.nuxt.test.js
+++ b/test/stores/Feedback.nuxt.test.js
@@ -34,11 +34,32 @@ describe("Feedback Store", () => {
       })
     })
 
+    describe("add_error", () => {
+      test("test feedbacks_timeout", () => {
+        feedback_store.feedbacks_timeout_miliseconds = 500
+        feedback_store.add_error(
+          500,
+          "/test",
+          "test message",
+          "test description",
+        )
+        expect(feedback_store.feedbacks.length).toBe(1)
+        setTimeout(() => {
+          expect(feedback_store.feedbacks.length).toBe(0)
+        }, 1000)
+      })
+    })
+
     describe("add_success", () => {
       test("test add_success", () => {
+        feedback_store.feedbacks_timeout_miliseconds = 500
         feedback_store.add_success("test description")
         expect(feedback_store.feedbacks.length).toBe(1)
         expect(feedback_store.feedbacks[0].type).toBe("success")
+
+        setTimeout(() => {
+          expect(feedback_store.feedbacks.length).toBe(0)
+        }, 1000)
       })
     })
     describe("delete_feedback", () => {
diff --git a/test/stores/Geode.nuxt.test.js b/test/stores/Geode.nuxt.test.js
index c13e0a1a..b1d5810a 100644
--- a/test/stores/Geode.nuxt.test.js
+++ b/test/stores/Geode.nuxt.test.js
@@ -3,6 +3,7 @@ import { createTestingPinia } from "@pinia/testing"
 import { describe, test, expect, expectTypeOf, beforeEach, vi } from "vitest"
 import { registerEndpoint } from "@nuxt/test-utils/runtime"
 import back_schemas from "@geode/opengeodeweb-back/schemas.json"
+import Status from "../utils/status"
 
 describe("Geode Store", () => {
   const pinia = createTestingPinia({
@@ -23,7 +24,7 @@ describe("Geode Store", () => {
     test("initial state", () => {
       expectTypeOf(geode_store.default_local_port).toBeString()
       expectTypeOf(geode_store.request_counter).toBeNumber()
-      expectTypeOf(geode_store.is_running).toBeBoolean()
+      expectTypeOf(geode_store.status).toBeString()
     })
   })
 
@@ -102,7 +103,7 @@ describe("Geode Store", () => {
         geode_store.base_url = ""
         getFakeCall.mockImplementation(() => ({}))
         await geode_store.do_ping()
-        expect(geode_store.is_running).toBe(true)
+        expect(geode_store.status).toBe(Status.CONNECTED)
         expect(feedback_store.server_error).toBe(false)
       })
       test("response_error", async () => {
@@ -114,7 +115,7 @@ describe("Geode Store", () => {
         })
 
         await geode_store.do_ping()
-        expect(geode_store.is_running).toBe(false)
+        expect(geode_store.status).toBe(Status.NOT_CONNECTED)
         expect(feedback_store.server_error).toBe(true)
       })
     })
diff --git a/test/stores/Infra.nuxt.test.js b/test/stores/Infra.nuxt.test.js
index f61f172d..ed95625d 100644
--- a/test/stores/Infra.nuxt.test.js
+++ b/test/stores/Infra.nuxt.test.js
@@ -1,7 +1,20 @@
-import { describe, test, expect, expectTypeOf, beforeEach } from "vitest"
+import { describe, test, expect, expectTypeOf, beforeEach, vi } from "vitest"
 import { registerEndpoint } from "@nuxt/test-utils/runtime"
 import { setActivePinia } from "pinia"
 import { createTestingPinia } from "@pinia/testing"
+import Status from "@/utils/status.js"
+
+// Mock navigator.locks API
+const mockLockRequest = vi.fn().mockImplementation(async (name, callback) => {
+  return callback({ name })
+})
+
+vi.stubGlobal("navigator", {
+  ...navigator,
+  locks: {
+    request: mockLockRequest,
+  },
+})
 
 describe("Infra Store", () => {
   const pinia = createTestingPinia({
@@ -23,7 +36,7 @@ describe("Infra Store", () => {
     test("initial state", () => {
       expectTypeOf(infra_store.ID).toBeString()
       expectTypeOf(infra_store.is_captcha_validated).toBeBoolean()
-      expectTypeOf(infra_store.is_connexion_launched).toBeBoolean()
+      expectTypeOf(infra_store.status).toBeString()
     })
   })
   describe("getters", () => {
@@ -57,26 +70,27 @@ describe("Infra Store", () => {
         )
       })
     })
-    describe("is_running", () => {
+    describe("status", () => {
       test("test geode false & viewer false", () => {
-        geode_store.$patch({ is_running: false })
-        viewer_store.$patch({ is_running: false })
-        expect(infra_store.is_running).toBe(false)
+        geode_store.$patch({ status: Status.NOT_CONNECTED })
+        viewer_store.$patch({ status: Status.NOT_CONNECTED })
+        console.log("Status", Status)
+        expect(infra_store.microservices_connected).toBe(false)
       })
       test("test geode true & viewer false", () => {
-        geode_store.$patch({ is_running: true })
-        viewer_store.$patch({ is_running: false })
-        expect(infra_store.is_running).toBe(false)
+        geode_store.$patch({ status: Status.CONNECTED })
+        viewer_store.$patch({ status: Status.NOT_CONNECTED })
+        expect(infra_store.microservices_connected).toBe(false)
       })
       test("test geode false & viewer true", () => {
-        geode_store.$patch({ is_running: false })
-        viewer_store.$patch({ is_running: true })
-        expect(infra_store.is_running).toBe(false)
+        geode_store.$patch({ status: Status.NOT_CONNECTED })
+        viewer_store.$patch({ status: Status.CONNECTED })
+        expect(infra_store.microservices_connected).toBe(false)
       })
       test("test geode true & viewer true", () => {
-        geode_store.$patch({ is_running: true })
-        viewer_store.$patch({ is_running: true })
-        expect(infra_store.is_running).toBe(true)
+        geode_store.$patch({ status: Status.CONNECTED })
+        viewer_store.$patch({ status: Status.CONNECTED })
+        expect(infra_store.microservices_connected).toBe(true)
       })
     })
 
@@ -84,39 +98,34 @@ describe("Infra Store", () => {
       test("test geode false & viewer false", () => {
         geode_store.$patch({ request_counter: 0 })
         viewer_store.$patch({ request_counter: 0 })
-        expect(infra_store.is_busy).toBe(false)
+        expect(infra_store.microservices_busy).toBe(false)
       })
       test("test geode true & viewer false", () => {
         geode_store.$patch({ request_counter: 1 })
         viewer_store.$patch({ request_counter: 0 })
-        expect(infra_store.is_busy).toBe(true)
+        expect(infra_store.microservices_busy).toBe(true)
       })
       test("test geode false & viewer true", () => {
         geode_store.$patch({ request_counter: 0 })
         viewer_store.$patch({ request_counter: 1 })
-        expect(infra_store.is_busy).toBe(true)
+        expect(infra_store.microservices_busy).toBe(true)
       })
       test("test geode true & viewer true", () => {
         geode_store.$patch({ request_counter: 1 })
         viewer_store.$patch({ request_counter: 1 })
-        expect(infra_store.is_busy).toBe(true)
+        expect(infra_store.microservices_busy).toBe(true)
       })
     })
   })
 
   describe("actions", () => {
-    describe("create_connexion", () => {
-      test("test without end-point", async () => {
-        await infra_store.create_connexion()
-        expect(infra_store.is_connexion_launched).toBe(true)
-        expect(feedback_store.server_error).toBe(true)
-      })
-    })
     describe("create_backend", () => {
       test("test without end-point", async () => {
         await infra_store.create_backend()
-        expect(geode_store.is_running).toBe(false)
-        expect(feedback_store.server_error).toBe(true)
+        console.log("geode_store.status", geode_store.status)
+        expect(infra_store.status).toBe(Status.CREATING)
+        expect(geode_store.status).toBe(Status.NOT_CONNECTED)
+        expect(viewer_store.status).toBe(Status.NOT_CONNECTED)
       })
       test("test with end-point", async () => {
         registerEndpoint(infra_store.lambda_url, {
@@ -124,7 +133,10 @@ describe("Infra Store", () => {
           handler: () => ({ ID: "123456" }),
         })
         await infra_store.create_backend()
-        expect(geode_store.is_running).toBe(true)
+        expect(infra_store.status).toBe(Status.CREATING)
+        expect(geode_store.status).toBe(Status.NOT_CONNECTED)
+        expect(viewer_store.status).toBe(Status.NOT_CONNECTED)
+        expect(feedback_store.server_error).toBe(false)
       })
     })
   })
diff --git a/test/stores/Viewer.nuxt.test.js b/test/stores/Viewer.nuxt.test.js
index b2ed9772..b926e3ec 100644
--- a/test/stores/Viewer.nuxt.test.js
+++ b/test/stores/Viewer.nuxt.test.js
@@ -18,13 +18,13 @@ describe("Viewer Store", () => {
     test("initial state", () => {
       expectTypeOf(viewer_store.default_local_port).toBeString()
       expectTypeOf(viewer_store.client).toEqualTypeOf({})
-      expectTypeOf(viewer_store.is_running).toBeBoolean()
       expectTypeOf(viewer_store.picking_mode).toBeBoolean()
       expectTypeOf(viewer_store.picked_point).toEqualTypeOf({
         x: null,
         y: null,
       })
       expectTypeOf(viewer_store.picked_point).toBeNumber()
+      expectTypeOf(viewer_store.status).toBeString()
     })
   })
 
diff --git a/utils/status.js b/utils/status.js
new file mode 100644
index 00000000..7532411e
--- /dev/null
+++ b/utils/status.js
@@ -0,0 +1,10 @@
+const Status = {
+  NOT_CREATED: "NOT_CREATED",
+  CREATING: "CREATING",
+  CREATED: "CREATED",
+  NOT_CONNECTED: "NOT_CONNECTED",
+  CONNECTING: "CONNECTING",
+  CONNECTED: "CONNECTED",
+}
+
+export default Status