diff --git a/crates/cuddle-ci/src/leptos_service.rs b/crates/cuddle-ci/src/leptos_service.rs
new file mode 100644
index 0000000..495e558
--- /dev/null
+++ b/crates/cuddle-ci/src/leptos_service.rs
@@ -0,0 +1,404 @@
+use std::{path::PathBuf, sync::Arc};
+
+use async_trait::async_trait;
+use dagger_rust::source::RustSource;
+use dagger_sdk::Container;
+use futures::{stream, StreamExt};
+
+use crate::{
+    dagger_middleware::DaggerMiddleware,
+    rust_service::{
+        architecture::{Architecture, Os},
+        extensions::CargoBInstallExt,
+        RustServiceStage,
+    },
+    MainAction, PullRequestAction,
+};
+
+#[derive(Clone)]
+pub struct LeptosService {
+    pub(crate) client: dagger_sdk::Query,
+    base_image: Option<dagger_sdk::Container>,
+    final_image: Option<dagger_sdk::Container>,
+    stages: Vec<RustServiceStage>,
+    source: Option<PathBuf>,
+    crates: Vec<String>,
+    bin_name: String,
+    arch: Option<Architecture>,
+    os: Option<Os>,
+    deploy_target_name: Option<String>,
+}
+
+impl LeptosService {
+    pub fn new(client: dagger_sdk::Query, bin_name: impl Into<String>) -> Self {
+        Self {
+            client,
+            base_image: None,
+            final_image: None,
+            stages: Vec::new(),
+            source: None,
+            crates: Vec::new(),
+            bin_name: bin_name.into(),
+            arch: None,
+            os: None,
+            deploy_target_name: None,
+        }
+    }
+
+    pub fn with_base_image(&mut self, base: dagger_sdk::Container) -> &mut Self {
+        self.base_image = Some(base);
+
+        self
+    }
+
+    pub fn with_stage(&mut self, stage: RustServiceStage) -> &mut Self {
+        self.stages.push(stage);
+
+        self
+    }
+
+    pub fn with_source(&mut self, path: impl Into<PathBuf>) -> &mut Self {
+        self.source = Some(path.into());
+
+        self
+    }
+
+    pub fn with_deploy_target(&mut self, deploy_target: impl Into<String>) -> &mut Self {
+        self.deploy_target_name = Some(deploy_target.into());
+
+        self
+    }
+
+    pub fn with_crates(
+        &mut self,
+        crates: impl IntoIterator<Item = impl Into<String>>,
+    ) -> &mut Self {
+        self.crates = crates.into_iter().map(|c| c.into()).collect();
+
+        self
+    }
+
+    pub fn with_arch(&mut self, arch: Architecture) -> &mut Self {
+        self.arch = Some(arch);
+
+        self
+    }
+
+    pub fn with_os(&mut self, os: Os) -> &mut Self {
+        self.os = Some(os);
+
+        self
+    }
+
+    fn get_src(&self) -> PathBuf {
+        self.source
+            .clone()
+            .unwrap_or(std::env::current_dir().unwrap())
+    }
+
+    pub fn get_arch(&self) -> Architecture {
+        self.arch
+            .clone()
+            .unwrap_or_else(|| match std::env::consts::ARCH {
+                "x86" | "x86_64" | "amd64" => Architecture::Amd64,
+                "arm" => Architecture::Arm64,
+                arch => panic!("unsupported architecture: {arch}"),
+            })
+    }
+
+    pub fn get_os(&self) -> Os {
+        self.os
+            .clone()
+            .unwrap_or_else(|| match std::env::consts::OS {
+                "linux" => Os::Linux,
+                "macos" => Os::MacOS,
+                os => panic!("unsupported os: {os}"),
+            })
+    }
+
+    async fn run_stage(
+        &self,
+        stages: impl IntoIterator<Item = &Arc<dyn DaggerMiddleware + Send + Sync>>,
+        container: Container,
+    ) -> eyre::Result<Container> {
+        let before_deps_stream = stream::iter(stages.into_iter().map(Ok));
+        let res = StreamExt::fold(before_deps_stream, Ok(container), |base, m| async move {
+            match (base, m) {
+                (Ok(base), Ok(m)) => m.handle(base).await,
+                (_, Err(e)) | (Err(e), _) => eyre::bail!("failed with {e}"),
+            }
+        })
+        .await?;
+
+        Ok(res)
+    }
+
+    pub async fn build_base(&self) -> eyre::Result<Container> {
+        let rust_src = RustSource::new(self.client.clone());
+
+        let (src, dep_src) = rust_src
+            .get_rust_src(Some(&self.get_src()), self.crates.clone())
+            .await?;
+
+        let base_image = self
+            .base_image
+            .clone()
+            .unwrap_or(self.client.container().from("rustlang/rust:nightly"));
+
+        let before_deps = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::BeforeDeps(middleware) => Some(middleware),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let image = self.run_stage(before_deps, base_image).await?;
+
+        let image = image.with_exec(vec!["rustup", "target", "add", "wasm32-unknown-unknown"]);
+
+        let after_deps = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::AfterDeps(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let image = self.run_stage(after_deps, image).await?;
+
+        let before_base = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::BeforeBase(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let image = self.run_stage(before_base, image).await?;
+
+        let cache = self.client.cache_volume("rust_target_cache");
+
+        let rust_prebuild = image
+            .with_workdir("/mnt/src")
+            .with_directory("/mnt/src", dep_src)
+            .with_exec(vec![
+                "cargo",
+                "leptos",
+                "build",
+                "--release",
+                "-vv",
+                "--project",
+                &self.bin_name,
+            ])
+            .with_mounted_cache("/mnt/src/target/", cache);
+
+        let incremental_dir = rust_src
+            .get_rust_target_src(&self.get_src(), rust_prebuild.clone(), self.crates.clone())
+            .await?;
+
+        let rust_with_src = image
+            .with_workdir("/mnt/src")
+            .with_directory(
+                "/usr/local/cargo",
+                rust_prebuild.directory("/usr/local/cargo"),
+            )
+            .with_directory("/mnt/src/target", incremental_dir)
+            .with_directory("/mnt/src/", src);
+
+        let after_base = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::AfterBase(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let image = self.run_stage(after_base, rust_with_src).await?;
+
+        Ok(image)
+    }
+
+    pub async fn build_release(&self) -> eyre::Result<Container> {
+        let base = self.build_base().await?;
+
+        let before_build = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::BeforeBuild(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let base = self.run_stage(before_build, base).await?;
+
+        let binary_build = base.with_exec(vec![
+            "cargo",
+            "leptos",
+            "build",
+            "--release",
+            "--project",
+            &self.bin_name,
+        ]);
+
+        let after_build = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::AfterBuild(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let binary_build = self.run_stage(after_build, binary_build).await?;
+
+        let dest = self
+            .final_image
+            .clone()
+            .unwrap_or(self.client.container().from("debian:bullseye"));
+
+        let before_package = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::BeforePackage(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let dest = self.run_stage(before_package, dest).await?;
+
+        let final_image = dest
+            .with_workdir("/mnt/app")
+            .with_file(
+                format!("/usr/local/bin/{}", self.bin_name),
+                binary_build.file(format!("/mnt/src/target/release/{}", self.bin_name)),
+            )
+            .with_directory(
+                "/mnt/app/target/site",
+                binary_build.directory("/mnt/src/target/site"),
+            )
+            .with_file(
+                "/mnt/app/Cargo.toml",
+                binary_build.file(format!("/mnt/src/crates/{}/Cargo.toml", self.bin_name)),
+            )
+            .with_env_variable("APP_ENVIRONMENT", "production")
+            .with_env_variable("LEPTOS_OUTPUT_NAME", &self.bin_name)
+            .with_env_variable("LEPTOS_SITE_ADDR", "0.0.0.0:3000")
+            .with_env_variable("LEPTOS_SITE_PKG_DIR", "pkg")
+            .with_exposed_port(3000);
+
+        let after_package = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::AfterPackage(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let final_image = self.run_stage(after_package, final_image).await?;
+
+        Ok(final_image)
+    }
+
+    pub async fn build_test(&self) -> eyre::Result<()> {
+        let base = self.build_base().await?;
+
+        let before_build = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::BeforeBuild(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let base = self.run_stage(before_build, base).await?;
+
+        base.with_exec(vec!["cargo", "test", "--release"])
+            .sync()
+            .await?;
+
+        Ok(())
+    }
+
+    fn get_deploy_target(&self) -> String {
+        self.deploy_target_name
+            .clone()
+            .unwrap_or(self.bin_name.clone())
+    }
+}
+
+#[async_trait]
+impl PullRequestAction for LeptosService {
+    async fn execute_pull_request(&self) -> eyre::Result<()> {
+        let mut s = self.clone();
+
+        s.with_cargo_binstall("latest", ["cargo-leptos"])
+            .build_test()
+            .await?;
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl MainAction for LeptosService {
+    async fn execute_main(&self) -> eyre::Result<()> {
+        let container = self.build_release().await?;
+        let timestamp = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+
+        container
+            .publish(format!(
+                "docker.io/kasperhermansen/{}:main-{}",
+                self.bin_name, timestamp,
+            ))
+            .await?;
+
+        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 Some(sock) = std::env::var("SSH_AUTH_SOCK").ok() {
+            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?;
+
+        Ok(())
+    }
+}
diff --git a/crates/cuddle-ci/src/lib.rs b/crates/cuddle-ci/src/lib.rs
index e0777d1..23905e2 100644
--- a/crates/cuddle-ci/src/lib.rs
+++ b/crates/cuddle-ci/src/lib.rs
@@ -1,4 +1,5 @@
 pub mod cli;
+pub mod leptos_service;
 pub use cli::*;
 
 pub mod dagger_middleware;
diff --git a/crates/cuddle-ci/src/rust_service/apt.rs b/crates/cuddle-ci/src/rust_service/apt.rs
index ad10b60..0f02ced 100644
--- a/crates/cuddle-ci/src/rust_service/apt.rs
+++ b/crates/cuddle-ci/src/rust_service/apt.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
 use async_trait::async_trait;
 use dagger_sdk::Container;
 
-use crate::dagger_middleware::DaggerMiddleware;
+use crate::{dagger_middleware::DaggerMiddleware, leptos_service::LeptosService};
 
 use super::RustService;
 
@@ -54,3 +54,11 @@ impl AptExt for RustService {
         )))
     }
 }
+
+impl AptExt for LeptosService {
+    fn with_apt(&mut self, deps: &[&str]) -> &mut Self {
+        self.with_stage(super::RustServiceStage::BeforeDeps(Arc::new(
+            Apt::new().extend(deps),
+        )))
+    }
+}
diff --git a/crates/cuddle-ci/src/rust_service/apt_ca_certificates.rs b/crates/cuddle-ci/src/rust_service/apt_ca_certificates.rs
index fa9ebd4..b4cac1f 100644
--- a/crates/cuddle-ci/src/rust_service/apt_ca_certificates.rs
+++ b/crates/cuddle-ci/src/rust_service/apt_ca_certificates.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
 use async_trait::async_trait;
 use dagger_sdk::Container;
 
-use crate::dagger_middleware::DaggerMiddleware;
+use crate::{dagger_middleware::DaggerMiddleware, leptos_service::LeptosService};
 
 use super::RustService;
 
@@ -51,3 +51,14 @@ impl AptCaCertificatesExt for RustService {
         )))
     }
 }
+
+impl AptCaCertificatesExt for LeptosService {
+    fn with_apt_ca_certificates(&mut self) -> &mut Self {
+        self.with_stage(super::RustServiceStage::BeforeDeps(Arc::new(
+            AptCaCertificates::new(),
+        )))
+        .with_stage(super::RustServiceStage::BeforePackage(Arc::new(
+            AptCaCertificates::new(),
+        )))
+    }
+}
diff --git a/crates/cuddle-ci/src/rust_service/assets.rs b/crates/cuddle-ci/src/rust_service/assets.rs
index a7ed13b..dd27002 100644
--- a/crates/cuddle-ci/src/rust_service/assets.rs
+++ b/crates/cuddle-ci/src/rust_service/assets.rs
@@ -3,7 +3,7 @@ use std::{path::PathBuf, sync::Arc};
 use async_trait::async_trait;
 use dagger_sdk::{Container, HostDirectoryOpts, HostDirectoryOptsBuilder};
 
-use crate::dagger_middleware::DaggerMiddleware;
+use crate::{dagger_middleware::DaggerMiddleware, leptos_service::LeptosService};
 
 use super::RustService;
 
@@ -58,3 +58,11 @@ impl AssetsExt for RustService {
         )))
     }
 }
+
+impl AssetsExt for LeptosService {
+    fn with_assets(&mut self, folders: impl IntoIterator<Item = (PathBuf, PathBuf)>) -> &mut Self {
+        self.with_stage(super::RustServiceStage::AfterPackage(Arc::new(
+            Assets::new(self.client.clone()).with_folders(folders),
+        )))
+    }
+}
diff --git a/crates/cuddle-ci/src/rust_service/cargo_binstall.rs b/crates/cuddle-ci/src/rust_service/cargo_binstall.rs
index 11e35de..3e70def 100644
--- a/crates/cuddle-ci/src/rust_service/cargo_binstall.rs
+++ b/crates/cuddle-ci/src/rust_service/cargo_binstall.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
 use async_trait::async_trait;
 use dagger_sdk::Container;
 
-use crate::dagger_middleware::DaggerMiddleware;
+use crate::{dagger_middleware::DaggerMiddleware, leptos_service::LeptosService};
 
 use super::{
     architecture::{Architecture, Os},
@@ -104,3 +104,17 @@ impl CargoBInstallExt for RustService {
         )))
     }
 }
+
+impl CargoBInstallExt for LeptosService {
+    fn with_cargo_binstall(
+        &mut self,
+        version: impl Into<String>,
+        crates: impl IntoIterator<Item = impl Into<String>>,
+    ) -> &mut Self {
+        let crates: Vec<String> = crates.into_iter().map(|s| s.into()).collect();
+
+        self.with_stage(super::RustServiceStage::BeforeDeps(Arc::new(
+            CargoBInstall::new(self.get_arch(), self.get_os(), version, crates),
+        )))
+    }
+}