diff --git a/tutorials/run-bun-serverless-containers/index.mdx b/tutorials/run-bun-serverless-containers/index.mdx
new file mode 100644
index 0000000000..b62cfb6eb4
--- /dev/null
+++ b/tutorials/run-bun-serverless-containers/index.mdx
@@ -0,0 +1,141 @@
+---
+title: Running a Bun application on Serverless Containers
+description: This page provides guidelines on how to host and deploy a Bun application using Scaleway Serverless Containers
+tags: deploy host website webapp bun javascript typescript containerize application docker dockerfile
+products:
+ - containers
+ - container-registry
+dates:
+ validation: 2026-07-17
+ posted: 2026-07-17
+ validation_frequency: 12
+difficulty: beginner
+usecase:
+ - application-hosting
+ - deploy-external-software
+ - website-hosting
+ecosystem:
+ - third-party
+---
+
+import Requirements from '@macros/iam/requirements.mdx'
+
+[Bun](https://bun.sh/) is an all-in-one JavaScript and TypeScript runtime toolkit built for speed, combining a fast bundler, transpiler, and package manager in a single binary. Hosting Bun on [Scaleway Serverless Containers](/serverless-containers/) provides automatic scaling, simplified deployment, and reduced infrastructure management. Thanks to Bun's quick startup time and small memory footprint, this combination is a great fit for serverless workloads, allowing you to minimize [cold starts](/serverless-containers/concepts/#cold-start) while focusing on writing code rather than maintaining servers.
+
+
+
+- A Scaleway account logged into the [console](https://console.scaleway.com)
+- [Owner](/iam/concepts/#owner) status or [IAM permissions](/iam/concepts/#permission) allowing you to perform actions in the intended Organization
+- Installed [Docker](https://docs.docker.com/get-started/get-docker/) or [Docker Engine](https://docs.docker.com/engine/install/)
+- Installed [Bun](https://bun.sh/) on your local machine
+- [Created a Scaleway Container Registry namespace](/container-registry/how-to/create-namespace/) and [logged into it](/container-registry/how-to/connect-docker-cli/)
+
+## Create and host a basic Bun application
+
+To host a [Bun](https://bun.sh/) web application on **Scaleway Serverless Containers**, you need to create a Bun project, implement a simple HTTP server using the native `Bun.serve` API, and containerize it using a production-ready `Dockerfile`. After building the image locally, push it to the [Scaleway Container Registry](/container-registry/) and deploy it via [Scaleway Serverless Containers](/serverless-containers/).
+
+### Create your app and test it locally
+
+1. In a terminal, create a new directory and navigate into it:
+ ```bash
+ mkdir my-bun-app
+ cd my-bun-app
+ ```
+
+2. Initialize a new Bun project:
+ ```bash
+ bun init -y
+ ```
+
+3. Create a `src` directory and add an `index.ts` file with the following code. This starts a simple HTTP server using Bun's native `Bun.serve` API:
+ ```ts
+ const PORT = process.env.PORT || 3000;
+
+ const server = Bun.serve({
+ port: PORT,
+ fetch(req) {
+ const url = new URL(req.url);
+ if (url.pathname === "/") {
+ return new Response("Hello from Bun on Scaleway Serverless Containers!");
+ }
+ return new Response("Not Found", { status: 404 });
+ },
+ });
+
+ console.log(`Bun app running on http://localhost:${server.port}`);
+ ```
+
+4. Verify your project structure:
+ ```
+ my-bun-app/
+ ├── src/
+ │ └── index.ts # HTTP server entry point
+ ├── package.json # Dependencies and scripts
+ ├── bun.lockb # Locked dependencies
+ └── tsconfig.json # TypeScript configuration
+ ```
+
+5. Run the following command to start your application locally:
+ ```bash
+ bun run src/index.ts
+ ```
+
+ Visit [http://localhost:3000](http://localhost:3000) to view your running Bun application.
+
+### Build the app image and push it to Scaleway Container Registry
+
+Before building and pushing your image, ensure you have [created a Scaleway Container Registry namespace](/container-registry/how-to/create-namespace/), and [logged into it with the Docker CLI](/container-registry/how-to/connect-docker-cli/).
+
+1. Create a `Dockerfile` at the root of your Bun app:
+ ```dockerfile
+ # Use the official Bun image
+ FROM oven/bun:1
+
+ # Set working directory
+ WORKDIR /app
+
+ # Copy the application code
+ COPY . .
+
+ # Expose port
+ EXPOSE 3000
+
+ # Run the Bun application
+ CMD ["bun", "run", "src/index.ts"]
+ ```
+
+2. Create a `.dockerignore` file in the same directory as your Dockerfile to keep the image lightweight:
+ ```
+ node_modules
+ .git
+ ```
+
+3. Build, tag, and push the image to Scaleway Container Registry:
+ ```bash
+ docker build \
+ --platform linux/amd64 \
+ --push \
+ -t /my-bun-app:latest .
+ ```
+
+
+ You can find your Container Registry endpoint in the **Overview** tab of your Container Registry namespace in the [Scaleway console](https://console.scaleway.com/registry/namespaces).
+
+
+### Deploy your app using Serverless Containers
+
+1. [Deploy a Serverless Container](/serverless-containers/how-to/deploy-container/) with the following settings:
+ - **Registry**: Scaleway Container Registry
+ - **Registry namespace**: The namespace where you pushed your image
+ - **Container port**: `3000` as it is the [port](/serverless-containers/reference-content/port-parameter-variable/) exposed in the dockerfile
+ - **Resources**: `500 mVCPU` and `512 MB` memory
+ - **Autoscaling**: Set minimum scale to `1` to avoid [cold starts](/serverless-containers/concepts/#cold-start) (optional)
+
+ Deployment may take up to a minute.
+
+2. Once the container is **ready**, click the **container endpoint** in the **Overview** tab. Your Bun app is live and accessible to anyone with the link.
+
+## Going further
+
+- You can deploy an existing Bun project by building and pushing its container image as shown above.
+- [Add a custom domain](/serverless-containers/how-to/add-a-custom-domain-to-a-container/) to your deployed app.