diff --git a/src/collections/resources/tutorials/deploy-aws-ec2.mdx b/src/collections/resources/tutorials/deploy-aws-ec2.mdx
new file mode 100644
index 0000000000000..dd0ee9e774e3c
--- /dev/null
+++ b/src/collections/resources/tutorials/deploy-aws-ec2.mdx
@@ -0,0 +1,86 @@
+---
+title: "Deploy AWS EC2 Instances with Meshery"
+thumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+darkthumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+date: 2025-04-24 10:30:05 -0530
+category: Cloud Native
+tags:
+  - Meshery
+  - AWS
+  - Tutorial
+type: Tutorial
+product: Meshery
+technology: AWS
+featured: false
+published: true
+resource: true
+---
+
+import { ResourcesWrapper } from "../Resources.style.js";
+
+<ResourcesWrapper>
+
+### Introduction
+
+Meshery is a powerful multi-cloud management platform that enables you to configure, deploy, and manage AWS resources such as EC2 instances. Meshery uses [AWS Controllers for Kubernetes (ACK)](https://aws.amazon.com/blogs/containers/aws-controllers-for-kubernetes-ack/) to bridge Kubernetes and AWS services. In this tutorial, we use the [Kanvas](https://docs.meshery.io/extensions/kanvas) extension to provide a visual experience for deploying an AWS EC2 instance.
+
+### Prerequisites
+
+1. A [self-hosted Meshery installation](https://docs.meshery.io/installation).
+2. An active AWS account.
+3. A running Kubernetes cluster (e.g., Minikube or EKS).
+
+### Overview of Deployment Steps
+
+1. **Connect your Kubernetes cluster to Meshery** — establishing the foundation for interacting with AWS resources via ACK.
+2. **Set up essential AWS resources** — deploy VPCs, subnets, and networking components for the EC2 instance.
+3. **Verify and monitor the deployment** — confirm EC2 instances via the AWS Console or Meshery's visualization mode.
+
+### Steps
+
+#### 1. Connect Your Kubernetes Cluster to Meshery
+
+1. For this guide, use the **in-cluster deployment** method. Follow the [Minikube setup guide](https://docs.meshery.io/installation/kubernetes/minikube) to deploy Meshery in-cluster.
+2. Open the Meshery UI at `localhost:9081` and verify that the cluster is listed.
+3. Click the cluster name to ping and confirm connectivity.
+
+#### 2. Configure and Deploy the EC2 Controller
+
+1. [Clone the EC2 controller design](https://cloud.layer5.io/catalog/content/catalog/ec2-controller-design-28a7fad9-c7ef-440a-a8f0-7614e072b866) from the Layer5 Catalog.
+2. Open the design in Kanvas. The design includes the EC2 Controller Pod, CRDs, Service Account, and an AWS Credentials Secret.
+
+**Configure the AWS Secret:**
+
+3. Double-click the **Secret** component.
+4. Under **Data**, add base64-encoded values:
+   - `AWS_ACCESS_KEY_ID`: your encoded key
+   - `AWS_SECRET_ACCESS_KEY`: your encoded secret
+5. Use a [base64 encoder](https://www.base64encode.org/) to encode your credentials.
+
+**Deploy the EC2 Controller:**
+
+6. Click **Actions > Deploy**.
+7. Once deployed, click **Open in Visualizer** to see the deployed resources in the `ack-system` namespace.
+
+#### 3. Deploy the VPC Workflow
+
+8. [Clone the VPC workflow design](https://cloud.layer5.io/catalog/content/catalog/vpc-workflow-design-50cac19e-209c-4acf-b91c-4784281db033) from the Catalog.
+9. Open the design and adjust CIDR blocks and region as needed (default: `us-east-1`).
+10. Click **Actions > Deploy**.
+11. Verify in your AWS Management Console that the VPC and networking resources are created.
+
+The VPC workflow includes: 1 VPC, 1 Internet Gateway, 1 NAT Gateway, 1 Elastic IP, 2 Route Tables, 2 Subnets, and 1 Security Group.
+
+#### 4. Deploy the EC2 Instance
+
+12. [Clone the EC2 instances design](https://cloud.layer5.io/catalog/content/catalog/ec2-instances-design-a344f109-2d92-41da-8644-3bc285c3ca9e) from the Catalog.
+13. Open the design in the Playground and click **Deploy**.
+14. Navigate to the AWS Management Console to confirm the instances are running.
+
+### Conclusion
+
+You've successfully deployed and managed AWS EC2 instances using Meshery. This guide demonstrated how to use pre-configured catalog designs, set up the ACK controller with AWS credentials, deploy VPC networking, and launch EC2 instances — all without CLI commands.
+
+> This tutorial is sourced from the [Meshery documentation](https://docs.meshery.io/guides/tutorials/aws/deploy-aws-ec2-instances-with-meshery).
+
+</ResourcesWrapper>
diff --git a/src/collections/resources/tutorials/kubernetes-configmaps-secrets.mdx b/src/collections/resources/tutorials/kubernetes-configmaps-secrets.mdx
new file mode 100644
index 0000000000000..b0b203fcf60d8
--- /dev/null
+++ b/src/collections/resources/tutorials/kubernetes-configmaps-secrets.mdx
@@ -0,0 +1,94 @@
+---
+title: "Understanding Kubernetes ConfigMaps and Secrets with Meshery"
+thumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+darkthumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+date: 2024-04-16 10:30:05 -0530
+category: Cloud Native
+tags:
+  - Meshery
+  - Kubernetes
+  - Tutorial
+type: Tutorial
+product: Meshery
+technology: Kubernetes
+featured: false
+published: true
+resource: true
+---
+
+import { ResourcesWrapper } from "../Resources.style.js";
+
+<ResourcesWrapper>
+
+### Introduction
+
+In this tutorial, we explore how to use **Kubernetes ConfigMaps and Secrets** with Meshery Playground. ConfigMaps allow you to decouple configuration from container images, while Secrets store sensitive data such as passwords and API keys securely.
+
+### Prerequisites
+
+- Basic understanding of Kubernetes Pods and Deployments.
+- Access to the *Meshery Playground*. Sign up at [Meshery Playground](https://play.meshery.io/) if needed.
+
+### Lab Scenario
+
+Create a ConfigMap and a Secret, then mount them into a Pod using Meshery's visual design canvas.
+
+### Objective
+
+Learn how to create **ConfigMaps** and **Secrets** and attach them to Pods using Meshery Playground.
+
+### Steps
+
+#### Access Meshery Playground
+
+1. Log in to [Meshery Playground](https://play.meshery.io) and click **Explore** to open *Kanvas*.
+2. Rename your design (e.g., `configmap-secrets-lab`).
+
+#### Create a ConfigMap
+
+1. In the **Components** tab, search for **ConfigMap** and drag it onto the canvas.
+2. Click the ConfigMap component to open its configuration.
+3. Under **data**, add a key-value pair, e.g.:
+   - Key: `APP_ENV`
+   - Value: `production`
+4. Give it a name (e.g., `app-config`) and a label.
+
+#### Create a Secret
+
+5. Search for **Secret** in Components and drag it onto the canvas.
+6. Click the Secret component and add base64-encoded data under **data**, e.g.:
+   - Key: `DB_PASSWORD`
+   - Value: `cGFzc3dvcmQ=` (base64 for "password")
+7. Name it (e.g., `app-secret`).
+
+#### Create a Pod and Mount ConfigMap and Secret
+
+8. Drag a **Pod** component onto the canvas.
+9. Add a container (`nginx:latest`) as covered in the Pods tutorial.
+10. In the container configuration, scroll to **envFrom** to reference the ConfigMap:
+    - Add a `configMapRef` pointing to `app-config`.
+11. Add another entry under **envFrom** referencing the Secret:
+    - Add a `secretRef` pointing to `app-secret`.
+12. Add a unique label to the pod for filtering.
+
+#### Validate and Deploy
+
+13. Click **Validate** and resolve any errors.
+14. Click **Deploy** to apply the design.
+
+#### Verify in Visualize
+
+15. Switch to **Visualize** and filter by your pod's label.
+16. Click the pod and examine the **Details** tab to confirm the configuration is applied.
+
+#### Clean Up
+
+17. Use **Undeploy** to remove all resources.
+
+### Conclusion
+
+You've successfully created Kubernetes ConfigMaps and Secrets and mounted them into a Pod using Meshery Playground. This approach enables clean separation of configuration from application code. 
+
+> This tutorial is sourced from the [Meshery documentation](https://docs.meshery.io/guides/tutorials/kubernetes/kubernetes-configmaps-secrets).
+
+</ResourcesWrapper>
diff --git a/src/collections/resources/tutorials/kubernetes-cronjobs.mdx b/src/collections/resources/tutorials/kubernetes-cronjobs.mdx
new file mode 100644
index 0000000000000..c32a302e50037
--- /dev/null
+++ b/src/collections/resources/tutorials/kubernetes-cronjobs.mdx
@@ -0,0 +1,86 @@
+---
+title: "Exploring Kubernetes CronJobs with Meshery"
+thumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+darkthumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+date: 2024-05-10 10:30:05 -0530
+category: Cloud Native
+tags:
+  - Meshery
+  - Kubernetes
+  - Tutorial
+type: Tutorial
+product: Meshery
+technology: Kubernetes
+featured: false
+published: true
+resource: true
+---
+
+import { ResourcesWrapper } from "../Resources.style.js";
+
+<ResourcesWrapper>
+
+### Introduction
+
+In this tutorial, we explore **Kubernetes CronJobs** using Meshery Playground. CronJobs create Jobs on a repeating schedule, making them ideal for periodic tasks like backups, report generation, or cleanup operations.
+
+### Prerequisites
+
+- Basic understanding of Kubernetes Pods and Jobs.
+- Access to *Meshery Playground*. Sign up at [Meshery Playground](https://play.meshery.io/) if needed.
+
+### Lab Scenario
+
+Create a CronJob that runs a simple task on a schedule using Meshery's visual canvas.
+
+### Objective
+
+Learn how to create and manage **Kubernetes CronJobs** visually using Meshery Playground.
+
+### Steps
+
+#### Access Meshery Playground
+
+1. Log in to [Meshery Playground](https://play.meshery.io) and click **Explore** to open *Kanvas*.
+2. Name your design (e.g., `cronjob-lab`).
+
+#### Create a CronJob
+
+1. In the **Components** tab, search for **CronJob** and drag it onto the canvas.
+2. Click the CronJob component to open its configuration modal.
+3. Set the **name** (e.g., `hello-cronjob`).
+4. Set the **schedule** field to `"*/1 * * * *"` — this runs the job every minute.
+5. Under **jobTemplate > spec > template > spec > containers**, click **+** to add a container:
+   - **name**: `hello`
+   - **image**: `busybox:latest`
+   - **command**: `["/bin/sh", "-c", "echo Hello from CronJob"]`
+6. Set **restartPolicy** to `OnFailure`.
+7. Add a unique label (e.g., `app: hello-cronjob`) for filtering.
+8. Click outside to close the modal.
+
+#### Validate and Deploy
+
+9. Click **Validate** to check for errors.
+10. Click **Deploy** to apply the CronJob.
+
+#### Visualize the CronJob
+
+11. Switch to **Visualize** and filter by the label set in step 7.
+12. Wait a minute — you should see a **Job** and a **Pod** appear as the CronJob triggers.
+13. Click the Pod in the **Details** tab to see its status and logs.
+
+#### View Job History
+
+14. In the Visualize view, filter for **Kind: Job** to see the history of completed jobs created by the CronJob.
+
+#### Clean Up
+
+15. Go back to **Design** view and use **Undeploy** to remove the CronJob and all associated resources.
+
+### Conclusion
+
+You've successfully created and managed a Kubernetes CronJob using Meshery Playground. CronJobs are a powerful way to automate periodic tasks in Kubernetes without external schedulers.
+
+> This tutorial is sourced from the [Meshery documentation](https://docs.meshery.io/guides/tutorials/kubernetes/exploring-kubernetes-cronjobs).
+
+</ResourcesWrapper>
diff --git a/src/collections/resources/tutorials/kubernetes-deployments.mdx b/src/collections/resources/tutorials/kubernetes-deployments.mdx
new file mode 100644
index 0000000000000..6e23a189b990a
--- /dev/null
+++ b/src/collections/resources/tutorials/kubernetes-deployments.mdx
@@ -0,0 +1,90 @@
+---
+title: "Exploring Kubernetes Deployments with Meshery"
+thumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+darkthumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+date: 2025-02-27 10:30:05 -0530
+category: Cloud Native
+tags:
+  - Meshery
+  - Kubernetes
+  - Tutorial
+type: Tutorial
+product: Meshery
+technology: Kubernetes
+featured: false
+published: true
+resource: true
+---
+
+import { ResourcesWrapper } from "../Resources.style.js";
+
+<ResourcesWrapper>
+
+### Introduction
+
+In this tutorial, we'll explore Kubernetes Deployments using [Meshery Playground](https://play.meshery.io/). Deployments provide declarative updates for Pods and ReplicaSets, making it easy to roll out changes, scale applications, and roll back to previous versions.
+
+### Prerequisites
+
+- Basic understanding of Kubernetes Pods.
+- Access to the *Meshery Playground*. Sign up at [Meshery Playground](https://play.meshery.io/) if needed.
+
+> **NOTE:** Consider completing the [Exploring Kubernetes Pods with Meshery](/resources/tutorials/exploring-kubernetes-pods-with-meshery) tutorial first.
+
+### Lab Scenario
+
+Create and manage an NGINX Deployment in Meshery Playground, explore scaling, and observe rolling updates.
+
+### Objective
+
+Learn how to create, scale, and manage **Kubernetes Deployments** visually using Meshery's Kanvas.
+
+### Steps
+
+#### Access Meshery Playground
+
+1. Log in to [Meshery Playground](https://play.meshery.io) and click **Explore** to open *Kanvas*.
+2. Rename the design to something identifiable (e.g., `nginx-deployment`).
+
+#### Create a Deployment
+
+1. Click the **Components** tab and search for **Deployment**.
+2. Drag the **Deployment** component onto the canvas.
+3. Click the Deployment component to open its configuration modal.
+4. Set the **name** (e.g., `nginx-deployment`).
+5. Under **spec**, set `replicas` to `2`.
+6. Under **template > spec > containers**, click **+** to add a container:
+   - **name**: `nginx`
+   - **image**: `nginx:latest`
+7. Add a label (e.g., `app: nginx-deploy`) to help filter resources.
+8. Click outside to close the modal.
+
+#### Validate and Deploy
+
+9. Click **Validate** to check for errors.
+10. Click **Deploy** in the popup, then **Deploy** again to apply.
+
+#### Visualize the Deployment
+
+11. Click **Visualize** and apply a filter using the label set in step 7.
+12. You should see the Deployment and its two managed Pods.
+13. Click the Deployment in the **Details** tab to view replicas, conditions, and the rollout strategy.
+
+#### Scale the Deployment
+
+14. Go back to **Design** view and click the Deployment component.
+15. Change `replicas` to `4`.
+16. **Undeploy** and **Deploy** again to apply the change.
+17. Switch to **Visualize** — you should now see 4 pods managed by the Deployment.
+
+#### Clean Up
+
+18. Use **Undeploy** from the Design view to remove all resources.
+
+### Conclusion
+
+You've successfully created and managed a Kubernetes Deployment using Meshery Playground. You scaled the deployment visually and observed how Kubernetes manages replica sets. Continue to the next tutorial to explore Kubernetes Services.
+
+> This tutorial is sourced from the [Meshery documentation](https://docs.meshery.io/guides/tutorials/kubernetes/kubernetes-deployments).
+
+</ResourcesWrapper>
diff --git a/src/collections/resources/tutorials/kubernetes-pods.mdx b/src/collections/resources/tutorials/kubernetes-pods.mdx
new file mode 100644
index 0000000000000..d947fb69d3a9e
--- /dev/null
+++ b/src/collections/resources/tutorials/kubernetes-pods.mdx
@@ -0,0 +1,95 @@
+---
+title: "Exploring Kubernetes Pods with Meshery"
+thumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+darkthumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+date: 2024-02-22 10:30:05 -0530
+category: Cloud Native
+tags:
+  - Meshery
+  - Kubernetes
+  - Tutorial
+type: Tutorial
+product: Meshery
+technology: Kubernetes
+featured: false
+published: true
+resource: true
+---
+
+import { ResourcesWrapper } from "../Resources.style.js";
+
+<ResourcesWrapper>
+
+### Introduction
+
+In this tutorial, we'll learn the fundamentals of Pods, the smallest deployable units in the Kubernetes ecosystem. Using [Meshery Playground](https://play.meshery.io/), an interactive live cluster environment, we'll perform hands-on labs to gain practical experience in deploying, managing, and understanding Pods.
+
+> **NOTE:** This tutorial demonstrates stand-alone pods, i.e. pods not managed through deployments.
+
+### Prerequisites
+
+- Basic understanding of containerization and Kubernetes concepts.
+- Access to the *Meshery Playground*. If you don't have an account, sign up at [Meshery Playground](https://play.meshery.io/).
+
+### Lab Scenario
+
+Deploy and explore an NGINX pod in a Kubernetes cluster. Additionally, expose the pod through a service.
+
+### Objective
+
+Learn how to create, manage, and explore **Kubernetes Pods and Services** within the context of a microservices architecture.
+
+### Steps
+
+#### Access Meshery Playground
+
+1. Log in to the [Meshery Playground](https://play.meshery.io) using your credentials.
+2. Click **Explore** in the Cloud Native Playground tile to navigate to *Kanvas*.
+
+#### Create a Simple Stand-alone Pod
+
+1. In the Kanvas screen, rename the design from *Untitled Design* to a name of your choice.
+2. Click the **Components** tab and search for **Pod**.
+3. Drag the **Pod** component from the search results to the design canvas.
+4. Click the pod component to load the configuration modal and rename the pod if necessary.
+
+#### Add a Container to the Pod
+
+5. Scroll down to the **Containers** section in the modal. Click **+** to add a container.
+6. Expand **Containers-0** and enter the container image: `nginx:latest`.
+7. Give the container a name and add a unique label (e.g., `app: my-pod`). This helps filter your resources in a shared playground environment.
+8. Click outside to close the modal.
+
+#### Validate and Deploy the Pod
+
+9. Click **Validate** on the top toolbar. Ensure there are no errors.
+10. Click the **Deploy** tab in the popup modal, then click **Deploy** again.
+
+#### Visualize the Pod
+
+11. Click **Visualize** to open the visualization view.
+12. Click the filter icon and select the label you set in step 7 to filter your resources.
+13. Select the **Details** tab and click the pod to see its state, namespace, image details, restarts, and uptime.
+
+#### Connect to the Pod
+
+14. Select the pod, then click the **Actions** tab.
+15. Click **Open Interactive Terminal** to connect to the container.
+16. Click **Stream Container Logs** to view live logs alongside the terminal.
+
+#### Expose the Pod with a Service
+
+17. Go back to the **Design** view. Search for **service** in Components and drag it to the canvas.
+18. Click the service component, rename it, and set **Type** to **NodePort**.
+19. Click **+** to add a Port. Set both **Port** and **Target Port** to `80`.
+20. Add a Selector with the same key-value pair used as the pod label (e.g., `app: my-pod`).
+21. Link the service to the pod by hovering over the service component's green dot, clicking the arrow, selecting **Network**, and connecting it to the pod.
+22. **Undeploy** and **Deploy** again to apply the updated design.
+
+### Conclusion
+
+Congratulations! You've successfully explored Kubernetes Pods using Meshery Playground. You deployed a pod, connected to it via terminal, streamed its logs, and exposed it through a NodePort service. Continue exploring more cloud native scenarios at [Meshery Playground](https://play.meshery.io/).
+
+> This tutorial is sourced from the [Meshery documentation](https://docs.meshery.io/guides/tutorials/kubernetes/kubernetes-pods).
+
+</ResourcesWrapper>
diff --git a/src/collections/resources/tutorials/kubernetes-services.mdx b/src/collections/resources/tutorials/kubernetes-services.mdx
new file mode 100644
index 0000000000000..e90951368a150
--- /dev/null
+++ b/src/collections/resources/tutorials/kubernetes-services.mdx
@@ -0,0 +1,96 @@
+---
+title: "Exploring Kubernetes Services with Meshery"
+thumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+darkthumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+date: 2024-03-10 10:30:05 -0530
+category: Cloud Native
+tags:
+  - Meshery
+  - Kubernetes
+  - Tutorial
+type: Tutorial
+product: Meshery
+technology: Kubernetes
+featured: false
+published: true
+resource: true
+---
+
+import { ResourcesWrapper } from "../Resources.style.js";
+
+<ResourcesWrapper>
+
+### Introduction
+
+In this tutorial, we explore **Kubernetes Services** using Meshery Playground. Services provide stable network endpoints for a set of Pods, enabling reliable communication between components regardless of Pod restarts or rescheduling.
+
+### Prerequisites
+
+- Completion of the [Exploring Kubernetes Pods with Meshery](/resources/tutorials/exploring-kubernetes-pods-with-meshery) tutorial.
+- Access to *Meshery Playground*.
+
+### Lab Scenario
+
+Create a Deployment and expose it using different Service types — ClusterIP, NodePort — through Meshery's visual canvas.
+
+### Objective
+
+Understand the different **Kubernetes Service types** and learn how to create and connect them to workloads visually using Meshery.
+
+### Steps
+
+#### Access Meshery Playground
+
+1. Log in to [Meshery Playground](https://play.meshery.io) and click **Explore** to open *Kanvas*.
+2. Name your design (e.g., `kubernetes-services-lab`).
+
+#### Create a Deployment
+
+1. Search for **Deployment** in Components and drag it to the canvas.
+2. Configure it with:
+   - **name**: `web-deployment`
+   - **replicas**: `2`
+   - Container image: `nginx:latest`
+   - Label: `app: web`
+
+#### Create a ClusterIP Service
+
+3. Search for **Service** in Components and drag it to the canvas.
+4. Click the service component and configure:
+   - **name**: `web-clusterip`
+   - **type**: `ClusterIP` (default)
+   - Add a Port: **port** `80`, **targetPort** `80`
+   - Add a Selector: `app: web`
+5. Connect the Service to the Deployment on the canvas using the relationship arrow.
+
+#### Create a NodePort Service
+
+6. Drag another **Service** component to the canvas.
+7. Configure it:
+   - **name**: `web-nodeport`
+   - **type**: `NodePort`
+   - Add a Port: **port** `80`, **targetPort** `80`
+   - Add a Selector: `app: web`
+
+#### Validate and Deploy
+
+8. Click **Validate** to check for errors.
+9. Click **Deploy** to apply all resources.
+
+#### Visualize and Explore
+
+10. Switch to **Visualize** and filter by label `app: web`.
+11. You should see the Deployment, its Pods, and both Services.
+12. Click each Service in the **Details** tab to observe the ClusterIP assigned and the NodePort number.
+
+#### Clean Up
+
+13. Use **Undeploy** to remove all resources.
+
+### Conclusion
+
+You've successfully created and explored Kubernetes Services using Meshery Playground. You learned the difference between ClusterIP and NodePort service types and how to visually connect services to deployments.
+
+> This tutorial is sourced from the [Meshery documentation](https://docs.meshery.io/guides/tutorials/kubernetes/kubernetes-services).
+
+</ResourcesWrapper>
diff --git a/src/collections/resources/tutorials/publish-to-artifacthub.mdx b/src/collections/resources/tutorials/publish-to-artifacthub.mdx
new file mode 100644
index 0000000000000..4587a67b31f89
--- /dev/null
+++ b/src/collections/resources/tutorials/publish-to-artifacthub.mdx
@@ -0,0 +1,88 @@
+---
+title: "Publishing Meshery Designs to ArtifactHub"
+thumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+darkthumbnail: ../../../assets/images/tutorials/intro-to-meshery.webp
+date: 2024-07-30 10:30:05 -0530
+category: Cloud Native
+tags:
+  - Meshery
+  - ArtifactHub
+  - Tutorial
+type: Tutorial
+product: Meshery
+technology: Kubernetes
+featured: false
+published: true
+resource: true
+---
+
+import { ResourcesWrapper } from "../Resources.style.js";
+
+<ResourcesWrapper>
+
+### Introduction
+
+[ArtifactHub](https://artifacthub.io/) is a web-based platform that enables discovery, installation, and publishing of cloud native packages. In this tutorial, we'll learn how to publish **Meshery Designs** to ArtifactHub, making your infrastructure patterns discoverable by the broader cloud native community.
+
+### Prerequisites
+
+- A [Meshery account](https://meshery.io/) with at least one saved design.
+- An [ArtifactHub account](https://artifacthub.io/).
+- A GitHub repository to host your design files.
+
+### Lab Scenario
+
+Export a Meshery Design and publish it to ArtifactHub as a discoverable cloud native artifact.
+
+### Objective
+
+Learn how to **export a Meshery Design** and **publish it to ArtifactHub** so that others can discover and reuse your infrastructure patterns.
+
+### Steps
+
+#### 1. Prepare Your Meshery Design
+
+1. Log in to [Meshery Playground](https://play.meshery.io) or your Meshery instance.
+2. Open or create the design you want to publish.
+3. Click **Actions > Export** to export the design.
+4. Save the exported `.yaml` file to your local machine.
+
+#### 2. Create a GitHub Repository
+
+5. Create a new public GitHub repository (e.g., `my-meshery-designs`).
+6. Add your exported design `.yaml` file to the repository.
+7. Create an `artifacthub-repo.yml` file in the repository root with the following content:
+
+```yaml
+repositoryID: <your-artifacthub-repo-id>
+owners:
+  - name: Your Name
+    email: your@email.com
+```
+
+8. Commit and push both files to the repository.
+
+#### 3. Register Your Repository on ArtifactHub
+
+9. Log in to [ArtifactHub](https://artifacthub.io/).
+10. Click your profile icon and select **Control Panel**.
+11. Click **Add repository**.
+12. Fill in the details:
+    - **Kind**: select `Meshery designs`
+    - **Name**: a display name for your repository
+    - **URL**: the GitHub URL to the directory containing your designs
+13. Click **Add** to register the repository.
+
+#### 4. Verify Publication
+
+14. ArtifactHub will scan your repository and index the designs within a few minutes.
+15. Search for your design on [ArtifactHub](https://artifacthub.io/) to confirm it is listed.
+16. Click the listing to verify the description, links, and design metadata appear correctly.
+
+### Conclusion
+
+You've successfully published a Meshery Design to ArtifactHub. Your infrastructure patterns are now discoverable by the cloud native community. Consider adding a README and proper metadata to your designs to improve their visibility and usability.
+
+> This tutorial is sourced from the [Meshery documentation](https://docs.meshery.io/guides/tutorials/artifacthub/publish-to-artifacthub).
+
+</ResourcesWrapper>
diff --git a/src/utils/redirects.yaml b/src/utils/redirects.yaml
index 2e7c94f642045..3ddcb93e21ffd 100644
--- a/src/utils/redirects.yaml
+++ b/src/utils/redirects.yaml
@@ -227,3 +227,7 @@ redirects:
     toPath: "/cloud-native-management/kanvas/collaborate/peer-reviews"
     redirectInBrowser: true
     isPermanent: true
+  - fromPath: "/learn/cloud-native-labs"
+    toPath: "/learn/kanvas-labs"
+    redirectInBrowser: true
+    isPermanent: true