diff --git a/crates/cuddle-ci/src/cuddle_releaser.rs b/crates/cuddle-ci/src/cuddle_releaser.rs
index d21b3ed..8750bfe 100644
--- a/crates/cuddle-ci/src/cuddle_releaser.rs
+++ b/crates/cuddle-ci/src/cuddle_releaser.rs
@@ -18,6 +18,34 @@ pub struct CuddleReleaserOptions {
     app: String,
 }
 
+pub enum CuddleEnv {
+    Prod,
+    Dev,
+}
+
+impl ToString for CuddleEnv {
+    fn to_string(&self) -> String {
+        match self {
+            CuddleEnv::Prod => "prod".into(),
+            CuddleEnv::Dev => "dev".into(),
+        }
+    }
+}
+
+impl TryInto<CuddleEnv> for String {
+    type Error = eyre::Error;
+
+    fn try_into(self) -> Result<CuddleEnv, Self::Error> {
+        let env = match self.as_str() {
+            "prod" => CuddleEnv::Prod,
+            "dev" => CuddleEnv::Dev,
+            _ => eyre::bail!("was not a valid env: {}", self),
+        };
+
+        Ok(env)
+    }
+}
+
 impl CuddleReleaser {
     pub async fn new(client: dagger_sdk::Query) -> eyre::Result<Self> {
         let cuddle_file = CuddleFile::from_cuddle_file().await?;
@@ -31,11 +59,8 @@ impl CuddleReleaser {
             folder: ".cuddle/tmp".into(),
         })
     }
-}
 
-#[async_trait]
-impl MainAction for CuddleReleaser {
-    async fn execute_main(&self, _ctx: &mut cli::Context) -> eyre::Result<()> {
+    pub async fn releaser(&self, env: CuddleEnv) -> eyre::Result<()> {
         let client = self.client.clone();
 
         if self.cuddle_file.deployment.is_none() {
@@ -49,7 +74,7 @@ impl MainAction for CuddleReleaser {
             .unwrap()
             .env
             .0
-            .get(&self.env.as_ref().unwrap_or(&"prod".to_string()).to_string())
+            .get(&self.env.as_ref().unwrap_or(&env.to_string()).to_string())
         {
             Some(c) => match c.clusters.first().take() {
                 Some(c) => c,
@@ -111,3 +136,10 @@ impl MainAction for CuddleReleaser {
         Ok(())
     }
 }
+
+#[async_trait]
+impl MainAction for CuddleReleaser {
+    async fn execute_main(&self, _ctx: &mut cli::Context) -> eyre::Result<()> {
+        Ok(())
+    }
+}
diff --git a/crates/cuddle-ci/src/leptos_service.rs b/crates/cuddle-ci/src/leptos_service.rs
index 7c286fd..eeb3355 100644
--- a/crates/cuddle-ci/src/leptos_service.rs
+++ b/crates/cuddle-ci/src/leptos_service.rs
@@ -10,7 +10,7 @@ use crate::{
     rust_service::{
         architecture::{Architecture, Os},
         extensions::CargoBInstallExt,
-        RustServiceStage,
+        RustServiceContext, RustServiceStage,
     },
     Context, MainAction, PullRequestAction,
 };
@@ -27,6 +27,7 @@ pub struct LeptosService {
     arch: Option<Architecture>,
     os: Option<Os>,
     deploy_target_name: Option<String>,
+    deploy: bool,
 }
 
 impl LeptosService {
@@ -42,6 +43,7 @@ impl LeptosService {
             arch: None,
             os: None,
             deploy_target_name: None,
+            deploy: true,
         }
     }
 
@@ -90,6 +92,12 @@ impl LeptosService {
         self
     }
 
+    pub fn with_deploy(&mut self, deploy: bool) -> &mut Self {
+        self.deploy = deploy;
+
+        self
+    }
+
     fn get_src(&self) -> PathBuf {
         self.source
             .clone()
@@ -341,7 +349,7 @@ impl PullRequestAction for LeptosService {
 
 #[async_trait]
 impl MainAction for LeptosService {
-    async fn execute_main(&self, _ctx: &mut Context) -> eyre::Result<()> {
+    async fn execute_main(&self, ctx: &mut Context) -> eyre::Result<()> {
         let mut s = self.clone();
 
         let container = s
@@ -354,56 +362,58 @@ impl MainAction for LeptosService {
             .unwrap()
             .as_secs();
 
-        container
-            .publish(format!(
-                "docker.io/kasperhermansen/{}:main-{}",
-                self.bin_name, timestamp,
-            ))
-            .await?;
+        let tag = format!(
+            "docker.io/kasperhermansen/{}:main-{}",
+            self.bin_name, timestamp,
+        );
+        container.publish(tag).await?;
+        ctx.set_image_tag(format!("main-{}", &timestamp.to_string()))?;
 
-        let update_deployments_docker_image =
-            "docker.io/kasperhermansen/update-deployment:1701123940";
-        let dep = self
-            .client
-            .container()
-            .from(update_deployments_docker_image);
+        if self.deploy {
+            let update_deployments_docker_image =
+                "docker.io/kasperhermansen/update-deployment:1701123940";
+            let dep = self
+                .client
+                .container()
+                .from(update_deployments_docker_image);
 
-        let dep = if let Ok(sock) = std::env::var("SSH_AUTH_SOCK") {
-            dep.with_unix_socket("/tmp/ssh_sock", self.client.host().unix_socket(sock))
-                .with_env_variable("SSH_AUTH_SOCK", "/tmp/ssh_sock")
-                .with_exec(vec![
-                    "update-deployment",
-                    "--repo",
-                    &format!(
-                        "git@git.front.kjuulh.io:kjuulh/{}-deployment.git",
-                        self.get_deploy_target()
-                    ),
-                    "--service",
-                    &self.bin_name,
-                    "--image",
-                    &format!("kasperhermansen/{}:main-{}", self.bin_name, timestamp),
-                ])
-        } else {
-            dep.with_env_variable("GIT_USERNAME", "kjuulh")
-                .with_env_variable(
-                    "GIT_PASSWORD",
-                    std::env::var("GIT_PASSWORD").expect("GIT_PASSWORD to be set"),
-                )
-                .with_exec(vec![
-                    "update-deployment",
-                    "--repo",
-                    &format!(
-                        "https://git.front.kjuulh.io/kjuulh/{}-deployment.git",
-                        self.get_deploy_target()
-                    ),
-                    "--service",
-                    &self.bin_name,
-                    "--image",
-                    &format!("kasperhermansen/{}:main-{}", self.bin_name, timestamp),
-                ])
-        };
+            let dep = if let Ok(sock) = std::env::var("SSH_AUTH_SOCK") {
+                dep.with_unix_socket("/tmp/ssh_sock", self.client.host().unix_socket(sock))
+                    .with_env_variable("SSH_AUTH_SOCK", "/tmp/ssh_sock")
+                    .with_exec(vec![
+                        "update-deployment",
+                        "--repo",
+                        &format!(
+                            "git@git.front.kjuulh.io:kjuulh/{}-deployment.git",
+                            self.get_deploy_target()
+                        ),
+                        "--service",
+                        &self.bin_name,
+                        "--image",
+                        &format!("kasperhermansen/{}:main-{}", self.bin_name, timestamp),
+                    ])
+            } else {
+                dep.with_env_variable("GIT_USERNAME", "kjuulh")
+                    .with_env_variable(
+                        "GIT_PASSWORD",
+                        std::env::var("GIT_PASSWORD").expect("GIT_PASSWORD to be set"),
+                    )
+                    .with_exec(vec![
+                        "update-deployment",
+                        "--repo",
+                        &format!(
+                            "https://git.front.kjuulh.io/kjuulh/{}-deployment.git",
+                            self.get_deploy_target()
+                        ),
+                        "--service",
+                        &self.bin_name,
+                        "--image",
+                        &format!("kasperhermansen/{}:main-{}", self.bin_name, timestamp),
+                    ])
+            };
 
-        dep.sync().await?;
+            dep.sync().await?;
+        }
 
         Ok(())
     }