diff --git a/docs/getting-started/advanced-application.md b/docs/getting-started/advanced-application.md
new file mode 100644
index 00000000000..c4972ce89a8
--- /dev/null
+++ b/docs/getting-started/advanced-application.md
@@ -0,0 +1,429 @@
+---
+---
+title: Deploy an Advanced Application
+---
+
+Now that you've deployed your first application, let's explore some of KubeVela's more advanced features: multi-environment deployments, policies, and workflows with manual approval.
+
+## Prerequisites
+
+Before starting, make sure you have:
+- ✅ Completed [Deploy Your First Application](./first-application)
+- ✅ Basic understanding of KubeVela applications
+- ✅ KubeVela installed and running
+
+## Step 1: Understanding Advanced Concepts
+
+Before we begin, let's understand the new concepts we'll use:
+
+### What are Policies?
+
+Policies are rules that affect how and where your application is deployed. Think of them as _"deployment instructions"_, or application level modifiers, that can:
+- Control where your app runs (which cluster, namespace, region)
+- Modify configurations for different environments
+- Apply security or compliance rules
+- Set resource constraints
+
+**Common Policy Types:**
+- **Topology Policy**: Specifies **where** to deploy - like choosing which Kubernetes cluster and namespace
+- **Override Policy**: Modifies **how** components behave between environments - like using more replicas in production than dev
+- **Shared Resource Policy**: Allows sharing resources (like ConfigMaps or Secrets) across multiple applications
+- **Garbage Collection Policy**: Controls how resources are cleaned up when applications are updated or deleted
+
+> 📖 **Want to explore more?** See the [full list of available policies](https://kubevela.io/docs/end-user/policies/references/) in the reference documentation.
+
+### What are Workflows?
+
+Workflows orchestrate the deployment process through a series of steps. Instead of deploying everything at once, workflows let you:
+- Deploy in stages (dev → staging → production)
+- Add approval gates between environments
+- Run validation checks before proceeding
+- Rollback if something goes wrong
+
+**Common Workflow Steps:**
+- **Deploy Step**: Executes the actual deployment with selected policies
+- **Suspend Step**: Pauses and waits for manual approval
+- **Notification Step**: Sends alerts to Slack, email, webhooks, etc.
+- **Step Group**: Groups multiple steps to run in parallel
+
+> 📖 **Want to explore more?** See the [full list of workflow steps](https://kubevela.io/docs/end-user/workflow/built-in-workflow-defs/) in the reference documentation.
+
+### How Everything Works Together
+
+Building on the Components and Traits you learned in the [first application tutorial](./first-application), now we add:
+
+1. **Components** define *what* to deploy (your application) - [see available types](https://kubevela.io/docs/end-user/components/references/)
+2. **Traits** add operational *behaviors* to components (scaling, ingress, storage) - [see available traits](https://kubevela.io/docs/end-user/traits/references/)
+3. **Policies** define *where* to deploy and *how* to modify configurations per environment
+4. **Workflows** orchestrate *when* and *in what order* to deploy
+
+Here's how they work together in practice:
+
+1. You define a **Component** (like a web API) with **Traits** (like scaling to 2 replicas)
+2. You create **Policies** that specify different environments and configurations:
+ - Topology policy: "deploy to dev namespace"
+ - Override policy: "in production, scale to 5 replicas instead of 2"
+3. Your **Workflow** orchestrates the deployment:
+ - Step 1: Deploy to dev environment using dev policies
+ - Step 2: Wait for manual approval
+ - Step 3: Deploy to production using production policies (which override the scaling)
+
+The result: Same component and traits, but different behavior in each environment thanks to policies and workflows!
+
+## Step 2: Prepare the Environments
+
+First, let's create a production namespace:
+
+```bash
+vela env init prod --namespace prod
+```
+
+Expected output:
+```console
+environment prod with namespace prod created
+```
+
+Verify both environments exist:
+
+```bash
+vela env ls
+```
+
+## Step 3: Create the Advanced Application
+
+Save the following as `advanced-app.yaml`:
+
+```yaml
+apiVersion: core.oam.dev/v1beta1
+kind: Application
+metadata:
+ name: advanced-app
+ namespace: default
+spec:
+ components:
+ - name: backend-api
+ type: webservice
+ properties:
+ image: oamdev/hello-world
+ ports:
+ - port: 8000
+ expose: true
+ env:
+ - name: APP_ENV
+ value: "development"
+ traits:
+ - type: scaler
+ properties:
+ replicas: 1
+
+ policies:
+ # Development environment configuration
+ - name: env-development
+ type: topology
+ properties:
+ clusters: ["local"]
+ namespace: "default"
+
+ # Production environment configuration
+ - name: env-production
+ type: topology
+ properties:
+ clusters: ["local"]
+ namespace: "prod"
+
+ # Production-specific overrides
+ - name: production-configs
+ type: override
+ properties:
+ components:
+ - name: backend-api
+ properties:
+ env:
+ - name: APP_ENV
+ value: "production"
+ traits:
+ - type: scaler
+ properties:
+ replicas: 3 # Scale up for production
+
+ workflow:
+ steps:
+ # Step 1: Deploy to development
+ - name: deploy-to-dev
+ type: deploy
+ properties:
+ policies: ["env-development"]
+
+ # Step 2: Wait for manual approval
+ - name: manual-approval
+ type: suspend
+ properties:
+ message: "Please review the development deployment before promoting to production"
+
+ # Step 3: Deploy to production
+ - name: deploy-to-prod
+ type: deploy
+ properties:
+ policies: ["env-production", "production-configs"]
+```
+
+## Step 4: Understanding the Configuration
+
+Let's break down what this configuration does:
+
+### Components Section
+- Defines a `backend-api` web service
+- Sets initial configuration (1 replica, development environment variable)
+
+### Policies Section
+1. **`env-development`**: Deploys to default namespace
+2. **`env-production`**: Deploys to prod namespace
+3. **`production-configs`**: Overrides settings for production (3 replicas, production env var)
+
+### Workflow Section
+1. **`deploy-to-dev`**: First deployment to development
+2. **`manual-approval`**: Pauses for human review
+3. **`deploy-to-prod`**: Deploys to production with overrides
+
+## Step 5: Deploy the Application
+
+Start the deployment:
+
+```bash
+vela up -f advanced-app.yaml
+```
+
+Expected output:
+```console
+Applying an application in vela K8s object format...
+✅ App has been deployed 🚀🚀🚀
+ Port forward: vela port-forward advanced-app
+ SSH: vela exec advanced-app
+ Logging: vela logs advanced-app
+ App status: vela status advanced-app
+ Endpoint: vela status advanced-app --endpoint
+```
+
+## Step 6: Check Development Deployment
+
+The application will first deploy to development and then wait for approval:
+
+```bash
+vela status advanced-app -n default
+```
+
+Expected output:
+```console
+About:
+
+ Name: advanced-app
+ Namespace: default
+ Created at: 2025-10-22 09:11:31 +0100 IST
+ Healthy: ✅
+ Details: workflowSuspending
+
+Workflow:
+
+ mode: StepByStep-DAG
+ finished: false
+ Suspend: true
+ Terminated: false
+ Steps
+ - id: igp5mle4ze
+ name: deploy-to-dev
+ type: deploy
+ phase: succeeded
+ - id: frqtbqtalg
+ name: manual-approval
+ type: suspend
+ phase: suspending
+ message: Suspended by field suspend
+
+Services:
+
+ - Name: backend-api
+ Cluster: local
+ Namespace: default
+ Type: webservice
+ Health: ✅
+ Message: Ready:1/1
+ Traits:
+ Type: scaler
+ Health: ✅
+```
+
+## Step 7: Test Development Deployment
+
+Access the development deployment:
+
+```bash
+vela port-forward advanced-app -n default 8001:8000
+```
+
+Visit http://localhost:8001 to verify it's working.
+
+## Step 8: Approve Production Deployment
+
+Once you've verified the development deployment, approve the promotion to production:
+
+```bash
+vela workflow resume advanced-app
+```
+
+Expected output:
+```console
+Successfully resume workflow: advanced-app
+```
+
+## Step 9: Verify Production Deployment
+
+Check the full deployment status:
+
+```bash
+vela status advanced-app -n default
+```
+
+You should now see services in both environments:
+
+```console
+Services:
+ - Name: backend-api
+ Cluster: local
+ Namespace: prod
+ Type: webservice
+ Health: ✅
+ Message: Ready:3/3
+ Traits:
+ Type: scaler
+ Health: ✅
+
+ - Name: backend-api
+ Cluster: local
+ Namespace: default
+ Type: webservice
+ Health: ✅
+ Message: Ready:1/1
+ Traits:
+ Type: scaler
+ Health: ✅
+```
+
+## Step 10: Test Production Deployment
+
+Access the production deployment:
+
+```bash
+vela port-forward advanced-app -n prod 8002:8000
+```
+
+Visit http://localhost:8002 to verify production is working.
+
+## Step 11: Managing Workflow States
+
+### View Workflow History
+
+```bash
+vela workflow logs advanced-app
+```
+
+### Restart a Workflow
+
+If needed, you can restart the entire workflow:
+
+```bash
+vela workflow restart advanced-app -n default
+```
+
+### Rollback a Deployment
+
+To rollback to a previous version:
+
+```bash
+vela workflow rollback advanced-app -n default
+```
+
+## Clean Up
+
+Delete the application and environments:
+
+```bash
+# Delete the application
+vela delete advanced-app -n default
+
+# Remove the production environment
+vela env delete prod
+```
+
+## What You've Learned
+
+In this advanced tutorial, you:
+- ✅ Created multi-environment deployments
+- ✅ Implemented environment-specific configurations
+- ✅ Used workflow steps with manual approval
+- ✅ Applied policies for topology and overrides
+- ✅ Managed complex application lifecycles
+
+## Troubleshooting
+
+
+Workflow stuck in suspended state
+
+Check the workflow status:
+```bash
+vela workflow logs advanced-app -n default
+```
+
+Resume if needed:
+```bash
+vela workflow resume advanced-app -n default
+```
+
+
+
+Production namespace not found
+
+Create it manually:
+```bash
+kubectl create namespace prod
+# or
+vela env init prod --namespace prod
+```
+
+
+
+Different replica counts not working
+
+Verify the override policy is correctly applied:
+```bash
+vela status advanced-app --tree -n default
+kubectl get deploy -n prod
+kubectl get deploy -n default
+```
+
+
+## Next Steps
+
+Now that you've mastered advanced deployments:
+
+- **[Create Your First Component](./first-component)** - Learn how to build custom reusable components
+- **[Multi-Cluster Deployments](../../case-studies/multi-cluster)** - Deploy across multiple Kubernetes clusters
+- **[GitOps Integration](../../case-studies/gitops)** - Automate with Git workflows
+- **[Helm Integration](../../tutorials/helm)** - Deploy Helm charts as components
+
+### Explore Built-in Definitions
+
+- **[Component Types Reference](https://kubevela.io/docs/end-user/components/references/)** - All available component types
+- **[Traits Reference](https://kubevela.io/docs/end-user/traits/references/)** - All available traits
+- **[Policies Reference](https://kubevela.io/docs/end-user/policies/references/)** - All available policies
+- **[Workflow Steps Reference](https://kubevela.io/docs/end-user/workflow/built-in-workflow-defs/)** - All available workflow steps
+
+
+## Summary
+
+You've successfully deployed an advanced KubeVela application with:
+- Multiple environment configurations
+- Manual approval workflows
+- Environment-specific overrides
+- Production-ready patterns
+
+These patterns form the foundation for real-world application deployments with KubeVela.
\ No newline at end of file
diff --git a/docs/getting-started/first-application.md b/docs/getting-started/first-application.md
new file mode 100644
index 00000000000..0cca3e19014
--- /dev/null
+++ b/docs/getting-started/first-application.md
@@ -0,0 +1,315 @@
+---
+title: Deploy Your First Application
+---
+
+In this guide, you'll deploy your first KubeVela application - a simple "Hello World" web service. This will help you understand the basic concepts and workflow.
+
+## Prerequisites
+
+Before starting, make sure you have:
+- ✅ [Installed KubeVela](quick-install)
+- ✅ Verified installation with `vela version`
+
+## Step 1: Understanding the Application Model
+
+Before diving into YAML, let's understand the core concepts:
+
+### What is an Application?
+
+An Application in KubeVela is a complete description of your microservice or system. It's the top-level resource that brings together all the pieces needed to run your software.
+
+### What are Components?
+
+Components are the building blocks of your application - they define **what** you want to deploy. A component encapsulates:
+- **Workloads**: Your actual running code (containers, functions, etc.)
+- **Resources**: Databases, message queues, cloud services
+- **Configurations**: Settings, environment variables, secrets
+
+Think of components as _"packaged units"_ of your application. For example:
+- A `webservice` component for your REST API
+- A `worker` component for background jobs
+- A `database` component for PostgreSQL
+
+Components are reusable and composable - you can use the same component type across different applications.
+
+### What are Traits?
+
+Traits are operational capabilities that you attach to components to add behaviors without changing the component itself. Think of them as _"plug-in features"_ that enhance your application:
+- **Scaling**: Control the number of replicas
+- **Ingress**: Expose your app to the internet
+- **Storage**: Attach persistent volumes
+- **Monitoring**: Add observability and metrics
+
+Traits are applied TO components. The same trait can work with different component types - for example, the `scaler` trait works with any deployable component.
+
+### How They Work Together
+
+```
+Application (online-store)
+├── Component: frontend (webservice)
+│ ├── Trait: scaler (replicas: 3)
+│ └── Trait: ingress (domain: store.example.com)
+└── Component: backend (webservice)
+ └── Trait: scaler (replicas: 2)
+```
+
+This separation of concerns means:
+- **Developers** focus on components (what to run)
+- **Operators** focus on traits (how to run it)
+- **Platform teams** can create reusable components and traits for everyone
+
+## Step 2: Create Your First Application
+
+Let's start with the simplest possible application - a web service:
+
+### Create the Application File
+
+Save the following as `hello-world.yaml`:
+
+```yaml
+apiVersion: core.oam.dev/v1beta1
+kind: Application
+metadata:
+ name: hello-world
+spec:
+ components:
+ - name: my-web-app
+ type: webservice
+ properties:
+ image: oamdev/hello-world
+ ports:
+ - port: 8000
+ expose: true
+```
+
+### What This Configuration Does
+
+**Application Metadata:**
+- **`apiVersion`**: Specifies the KubeVela API version
+- **`kind: Application`**: Declares this as a KubeVela Application
+- **`metadata.name`**: Names your application "hello-world"
+
+**Component Definition:**
+- **`type: webservice`**: Uses the built-in webservice component type
+- **`image`**: The container image to run
+- **`ports`**: Exposes port 8000 for access
+
+## Step 3: Deploy the Application
+
+Deploy your application with a single command:
+
+```bash
+vela up -f hello-world.yaml
+```
+
+You should see output like:
+```console
+Applying an application in vela K8s object format...
+✅ App has been deployed 🚀🚀🚀
+ Port forward: vela port-forward hello-world
+ SSH: vela exec hello-world
+ Logging: vela logs hello-world
+ App status: vela status hello-world
+ Endpoint: vela status hello-world --endpoint
+```
+
+## Step 4: Check Application Status
+
+Verify your application is running:
+
+```bash
+vela status hello-world
+```
+
+Expected output:
+```console
+About:
+
+ Name: hello-world
+ Namespace: default
+ Created at: 2025-10-22 09:00:52 +0100 IST
+ Healthy: ✅
+ Details: running
+
+...
+
+Services:
+ - Name: my-web-app
+ Cluster: local
+ Namespace: default
+ Type: webservice
+ Health: ✅
+ Message: Ready:1/1
+ No trait applied
+```
+
+## Step 5: Access Your Application
+
+Now let's see your app in action!
+
+```bash
+vela port-forward hello-world 8000:8000
+```
+
+This will:
+- Forward port 8000 from your application to your local machine
+- Automatically open your browser (on some systems)
+
+Navigate to http://localhost:8000 in your browser. You should see:
+
+```
+Hello KubeVela! Make shipping applications more enjoyable.
+```
+
+**Congratulations!** You've successfully deployed your first KubeVela application!
+
+## Step 6: Explore Your Application
+
+### View Logs
+
+Check what your application is doing:
+
+```bash
+vela logs hello-world
+```
+
+### Execute Commands
+
+Run commands inside your container:
+
+```bash
+vela exec hello-world -- ls -la
+```
+
+### List All Applications
+
+See all deployed applications:
+
+```bash
+vela ls
+```
+
+## Step 7: Add a Trait (Optional)
+
+Let's enhance your application by adding a scaling trait. Update your `hello-world.yaml`:
+
+```yaml
+apiVersion: core.oam.dev/v1beta1
+kind: Application
+metadata:
+ name: hello-world
+spec:
+ components:
+ - name: my-web-app
+ type: webservice
+ properties:
+ image: oamdev/hello-world
+ ports:
+ - port: 8000
+ expose: true
+ traits:
+ - type: scaler
+ properties:
+ replicas: 3
+```
+
+Apply the changes:
+
+```bash
+vela up -f hello-world.yaml
+```
+
+Check the status to see 3 replicas running:
+
+```bash
+vela status hello-world
+```
+
+## Step 8: Access the UI Console (Optional)
+
+If you installed VelaUX, you can manage your application visually:
+
+```bash
+# Port forward the UI
+vela port-forward addon-velaux -n vela-system 8080:80
+```
+
+Open http://localhost:8080 and login:
+- Username: `admin`
+- Password: `VelaUX12345` (you'll be prompted to change it)
+
+In the UI, you can:
+- View your application's topology
+- Inspect resources
+- Monitor health status
+- Make configuration changes
+
+## Clean Up
+
+When you're done experimenting:
+
+```bash
+vela delete hello-world
+```
+
+Confirm deletion:
+```console
+Start deleting application default/hello-world
+Delete application default/hello-world succeeded
+```
+
+## What You've Learned
+
+In this tutorial, you:
+- ✅ Created a KubeVela application configuration
+- ✅ Deployed a web service component
+- ✅ Accessed your running application
+- ✅ Added operational traits
+- ✅ Explored management commands
+- ✅ Used the UI console (optional)
+
+## Common Issues and Solutions
+
+
+Application stuck in "rendering" status
+
+This usually means there's an issue with your configuration. Check:
+- YAML syntax is correct
+- Image name and tag exist
+- Port configuration is valid
+
+Run `vela status hello-world --tree` for detailed error messages.
+
+
+
+Port forwarding doesn't work
+
+Make sure:
+- The application is in "running" status
+- The port number matches your configuration
+- No other process is using port 8000
+
+Try a different local port: `vela port-forward hello-world 8080:8000`
+
+
+
+Can't access VelaUX
+
+Verify VelaUX is installed:
+```bash
+vela addon list | grep velaux
+```
+
+If not installed:
+```bash
+vela addon enable velaux
+```
+
+
+## Next Steps
+
+Now that you've deployed your first application, you're ready to:
+
+- **[Deploy an Advanced Application](../advanced-application)** - Learn about multi-environment deployments
+- **[Understand Core Concepts](../core-concept)** - Deep dive into KubeVela's architecture
+- **[Explore Examples](https://github.com/kubevela/kubevela/tree/master/docs/examples)** - View the community curated examples
\ No newline at end of file
diff --git a/docs/getting-started/first-component.md b/docs/getting-started/first-component.md
new file mode 100644
index 00000000000..27e5bf834d8
--- /dev/null
+++ b/docs/getting-started/first-component.md
@@ -0,0 +1,371 @@
+---
+title: Creating Your First Component
+---
+
+Learn how to create custom KubeVela components to package and reuse your application configurations.
+
+## Prerequisites
+
+Before starting, make sure you have:
+- ✅ Completed [Deploy Your First Application](first-application)
+- ✅ Basic understanding of YAML and Kubernetes concepts
+- ✅ KubeVela installed and running
+
+## What Are Components?
+
+Components in KubeVela are reusable building blocks that define your application workloads. While KubeVela provides built-in components like `webservice` and `worker`, you can create custom components for specific needs.
+
+## Step 1: Understanding Component Definitions
+
+In KubeVela, components are defined using CUE templates that can generate any type of Kubernetes resource. This flexibility allows you to capture a wide range of infrastructure and application needs:
+
+### Standard Kubernetes Workloads
+- **Deployments** - Stateless applications (web APIs, microservices)
+- **StatefulSets** - Stateful applications (databases, message queues)
+- **DaemonSets** - Node-level services (logging agents, monitoring)
+- **Jobs/CronJobs** - Batch processing and scheduled tasks
+
+### Cloud Resources
+- **Managed Databases** - RDS, CloudSQL, Azure Database
+- **Storage** - S3 buckets, blob storage, persistent volumes
+- **Networking** - Load balancers, VPCs, security groups
+- **Compute** - Virtual machines, serverless functions
+
+### Observability & Operations
+- **ServiceMonitor** - Prometheus monitoring configuration
+- **HorizontalPodAutoscaler** - Auto-scaling policies
+- **NetworkPolicy** - Security and traffic rules
+- **PodDisruptionBudget** - Availability guarantees
+
+### Custom Resources
+- **Istio Resources** - VirtualServices, DestinationRules
+- **Cert-Manager** - Certificate management
+- **FluxCD/ArgoCD** - GitOps resources
+- **Application-specific CRDs** - Your custom operators
+
+The CUE template defines a user-friendly schema (what parameters they configure) and generates the complex underlying Kubernetes manifests automatically.
+
+## Step 2: Create a Simple Custom Component
+
+Before starting, make sure you are using the default environment:
+```bash
+vela env set default
+```
+
+Let's create a super simple component that demonstrates the power of abstraction. We'll make a `my-simple-deployment` component that only requires an image and replicas - but generates all the Kubernetes YAML automatically.
+
+### Define the Component
+
+Create a file called `simple-deployment.cue`:
+
+```cue
+"my-simple-deployment": {
+ annotations: {}
+ attributes: {
+ workload: {
+ definition: {
+ apiVersion: "apps/v1"
+ kind: "Deployment"
+ }
+ type: "deployments.apps"
+ }
+ }
+ description: "Simple deployment with configurable image and replicas"
+ labels: {}
+ type: "component"
+}
+
+template: {
+ parameter: {
+ // Simple parameters - that's it!
+ image: string
+ replicas: *1 | int
+ }
+
+ // Generate the complex Deployment automatically
+ output: {
+ apiVersion: "apps/v1"
+ kind: "Deployment"
+ metadata: {
+ name: context.name
+ }
+ spec: {
+ replicas: parameter.replicas
+ selector: matchLabels: {
+ app: context.name
+ }
+ template: {
+ metadata: labels: {
+ app: context.name
+ }
+ spec: containers: [{
+ name: "main"
+ image: parameter.image
+ ports: [{
+ containerPort: 8080
+ }]
+ }]
+ }
+ }
+ }
+}
+```
+
+**What's powerful here:**
+- Users only need to specify `image` and `replicas`
+- KubeVela automatically generates labels, selectors, metadata, and container specs
+- The abstraction hides Kubernetes complexity while providing flexibility
+
+### Apply the Component Definition
+
+```bash
+vela def apply simple-deployment.cue
+```
+
+Verify it was created:
+
+```bash
+vela def list --type component
+```
+
+You should see `my-simple-deployment` in the list.
+
+## Step 3: Use Your Custom Component
+
+Now create an application using your custom component. Look how simple this is!
+
+Create `my-app.yaml`:
+
+```yaml
+apiVersion: core.oam.dev/v1beta1
+kind: Application
+metadata:
+ name: my-app
+spec:
+ components:
+ - name: my-simple-deployment-app
+ type: my-simple-deployment # Your custom component!
+ properties:
+ image: nginx:alpine
+ replicas: 3
+```
+
+**That's it!** Just 2 parameters, but it creates a complete Deployment with proper labels, selectors, and all the Kubernetes boilerplate.
+
+Deploy it:
+
+```bash
+vela up -f my-app.yaml
+```
+
+Check what was actually created:
+
+```bash
+vela status my-app --tree
+```
+
+You'll see KubeVela generated a full Deployment resource from your simple configuration!
+
+## Advanced: Enhancing Your Component with Status Evaluation
+
+Now let's enhance our `my-simple-deployment` component with advanced status evaluation features. This will give operators better visibility into the health of their deployments.
+
+Update your `simple-deployment.cue` file to include status evaluation:
+
+```cue
+"my-simple-deployment": {
+ annotations: {}
+ attributes: {
+ workload: {
+ definition: {
+ apiVersion: "apps/v1"
+ kind: "Deployment"
+ }
+ type: "deployments.apps"
+ }
+ status: {
+ healthPolicy: #"""
+ isHealth: (context.output.status.readyReplicas > 0) && (context.output.status.readyReplicas == context.output.status.replicas)
+ """#
+ customStatus: #"""
+ message: "Ready: \(context.output.status.readyReplicas)/\(context.output.status.replicas)"
+ """#
+ details: #"""
+ desiredReplicas: *context.output.status.replicas | 0
+ readyReplicas: *context.output.status.readyReplicas | 0
+ availableReplicas: *context.output.status.availableReplicas | 0
+ unavailableReplicas: *context.output.status.unavailableReplicas | 0
+ """#
+ }
+ }
+ description: "Simple deployment with configurable image and replicas"
+ labels: {}
+ type: "component"
+}
+
+template: {
+ parameter: {
+ // Simple parameters - that's it!
+ image: string
+ replicas: *1 | int
+ }
+
+ // Generate the complex Deployment automatically
+ output: {
+ apiVersion: "apps/v1"
+ kind: "Deployment"
+ metadata: {
+ name: context.name
+ }
+ spec: {
+ replicas: parameter.replicas
+ selector: matchLabels: {
+ app: context.name
+ }
+ template: {
+ metadata: labels: {
+ app: context.name
+ }
+ spec: containers: [{
+ name: "main"
+ image: parameter.image
+ ports: [{
+ containerPort: 8080
+ }]
+ }]
+ }
+ }
+ }
+}
+```
+
+**What's new in the enhanced component:**
+- **`healthPolicy`**: Defines when the component is considered healthy (all replicas are ready)
+- **`customStatus`**: Provides a custom status message showing ready vs total replicas
+- **`details`**: Exposes structured status information including conditions and replica counts
+
+### Apply the Enhanced Component
+
+Update your component definition:
+
+```bash
+vela def apply simple-deployment.cue
+```
+
+This will create a second revision of the component. You can view the revisions with:
+```bash
+kubectl get definitionrevision --all-namespaces | grep my-simple-deployment
+```
+
+Now redeploy your application to see the enhanced status features:
+
+```bash
+vela up -f my-app.yaml
+```
+
+Check the enhanced status information:
+
+```bash
+vela status my-app
+```
+
+Instead of needing multiple kubectl commands, they see:
+```
+About:
+
+ Name: my-simple-app
+ Namespace: default
+ Created at: 2025-10-22 11:41:17 +0100 IST
+ Healthy: ✅
+ Details: running
+
+...
+
+Services:
+ - Name: my-simple-deployment
+ Cluster: local
+ Namespace: default
+ Type: my-simple-deployment
+ Health: ✅
+ Message: Ready: 3/3
+ Status Details:
+ availableReplicas: 3
+ desiredReplicas: 3
+ readyReplicas: 3
+ unavailableReplicas: 0
+ No trait applied
+```
+
+**Key Benefits:**
+- **No Kubernetes expertise required** - Operators see application health, not infrastructure details
+- **Contextual information** - Only relevant status is surfaced
+- **Consistent interface** - Same `vela status` command works for any component type
+- **Actionable insights** - Clear messages about what's working or what needs attention
+
+## Troubleshooting
+
+
+Component definition not found
+
+Check if the component is registered:
+```bash
+vela def list --type component
+vela def get -t component
+```
+
+Re-apply if needed:
+```bash
+vela def apply your-component.cue
+```
+
+
+
+CUE syntax errors
+
+Validate your CUE template:
+```bash
+vela def vet your-component.cue
+```
+
+Check the rendered output:
+```bash
+vela dry-run -f your-app.yaml
+```
+
+
+
+Component not working with traits
+
+Ensure your component outputs the correct workload type:
+- Deployment for scaler, rollout traits
+- Service for ingress trait
+- Check trait requirements with `vela traits`
+
+
+## What You've Learned
+
+In this tutorial, you:
+- ✅ Created custom component definitions
+- ✅ Used CUE templates to define component schemas
+- ✅ Deployed applications with custom components
+- ✅ Combined components with traits
+- ✅ Learned to package and share components
+
+## Next Steps
+
+This has given a brief introduction to writing custom definitions through CUE. For detailed information see:
+
+### CUE Fundamentals
+- **[CUE Basics](../../platform-engineers/cue/basic)** - Learn CUE language fundamentals
+- **[Definition Editing](../../platform-engineers/cue/definition-edit)** - CUE definition overview
+
+### Creating Custom Definitions
+- **[Custom Components](../../platform-engineers/components/custom-component)** - Build reusable component definitions
+- **[Custom Traits](../../platform-engineers/traits/customize-trait)** - Create operational behaviors
+- **[Custom Policies](../../platform-engineers/policy/custom-policy)** - Define deployment policies
+- **[Custom Workflows](../../platform-engineers/workflow/workflow)** - Build deployment pipelines
+
+### Advanced Features
+- **[External Packages](../../platform-engineers/cue/external-packages)** - Using external CUE packages
+- **[Component Health Status](../../platform-engineers/status/definition_health_status)** - Advanced status evaluation
+
diff --git a/docs/getting-started/quick-install.md b/docs/getting-started/quick-install.md
new file mode 100644
index 00000000000..bce3b5b3b5d
--- /dev/null
+++ b/docs/getting-started/quick-install.md
@@ -0,0 +1,52 @@
+---
+title: Quick Install
+---
+
+Choose the installation method that best fits your environment:
+
+## Option A: Standalone (No Kubernetes Required)
+
+Perfect for beginners and local development. VelaD includes everything you need:
+
+```bash
+# Install VelaD (includes KubeVela + Kubernetes)
+curl -fsSl https://static.kubevela.net/script/install-velad.sh | bash
+
+# Start KubeVela with UI console
+velad install --set enableHA=false
+```
+
+> 📖 **Need more details?** See the full [Standalone Installation Guide](../installation/standalone) for platform-specific instructions.
+
+## Option B: Existing Kubernetes Cluster
+
+If you already have a Kubernetes cluster:
+
+```bash
+# Install the vela CLI
+curl -fsSl https://kubevela.io/script/install.sh | bash
+
+# Install KubeVela to your cluster
+vela install
+
+# Install the UI console (VelaUX)
+vela addon enable velaux
+```
+
+> 📖 **Need more details?** See the full [Kubernetes Installation Guide](../installation/kubernetes) for Helm installation and production configurations.
+
+## Verify Installation
+
+```bash
+vela version
+```
+
+You should see:
+```
+CLI Version: v1.10.x
+Core Version: v1.10.x
+```
+
+## Next Steps
+
+✅ Installation complete! Now continue to [Deploy Your First App](../getting-started/first-application).
\ No newline at end of file
diff --git a/docs/quick-start.md b/docs/quick-start.md
index d68af415b16..f145eb3d89f 100644
--- a/docs/quick-start.md
+++ b/docs/quick-start.md
@@ -1,269 +1,59 @@
---
-title: Deploy First Application
+title: Getting Started Overview
---
-:::note
-Before starting, please confirm that you've installed KubeVela and enabled the VelaUX addon according to [the installation guide](./install.mdx).
-:::
+Welcome to KubeVela! 🚀
-Welcome to KubeVela! This section will guide you to deliver your first app.
+This guide will walk you through everything you need to start using KubeVela, from installation to deploying advanced applications.
-## Deploy a classic application
+## Quick Start Path
-Below is a classic KubeVela application which contains one component with one operational trait, basically, it means to deploy a container image as webservice with one replica. Additionally, there are three policies and workflow steps, it means to deploy the application into two different environments with different configurations.
+Follow these steps in order to get up and running with KubeVela:
-```yaml
-apiVersion: core.oam.dev/v1beta1
-kind: Application
-metadata:
- name: first-vela-app
-spec:
- components:
- - name: express-server
- type: webservice
- properties:
- image: oamdev/hello-world
- ports:
- - port: 8000
- expose: true
- traits:
- - type: scaler
- properties:
- replicas: 1
- policies:
- - name: target-default
- type: topology
- properties:
- # The cluster with name local is installed the KubeVela.
- clusters: ["local"]
- namespace: "default"
- - name: target-prod
- type: topology
- properties:
- clusters: ["local"]
- # This namespace must be created before deploying.
- namespace: "prod"
- - name: deploy-ha
- type: override
- properties:
- components:
- - type: webservice
- traits:
- - type: scaler
- properties:
- replicas: 2
- workflow:
- steps:
- - name: deploy2default
- type: deploy
- properties:
- policies: ["target-default"]
- - name: manual-approval
- type: suspend
- - name: deploy2prod
- type: deploy
- properties:
- policies: ["target-prod", "deploy-ha"]
-```
+
-* Create an environment for your first app.
+### 1. 📦 [Quick Install](../getting-started/quick-install)
+Choose between standalone installation (no Kubernetes required) or installing on an existing cluster.
-```bash
-# This command will create a namespace in the local cluster
-vela env init prod --namespace prod
-```
+### 2. 🚀 [Deploy Your First App](../getting-started/first-application)
+Start with a simple "Hello World" application to learn the basics.
-
-expected output
+### 3. 🏗️ [Deploy an Advanced App](../getting-started/advanced-application)
+Learn about multi-environment deployments, policies, and workflows.
-```console
-environment prod with namespace prod created
-```
-
+### 4. 🔧 [Create Your First Component](../getting-started/first-component)
+Build custom reusable components for your applications.
-* Starting to deploy the application
+### 5. 📚 [Explore Tutorials](../tutorials/webservice)
+Discover tutorials, best practices, and advanced features.
-```
-vela up -f https://kubevela.io/example/applications/first-app.yaml
-```
+### 6. 📦 [Browse Examples](https://github.com/kubevela/kubevela/tree/master/docs/examples)
+View community curated examples and real-world use cases.
-
-expected output
+### 7. 🤝 [Consider Contributing!](../contributor/overview)
+Join the KubeVela community and help shape the future of application delivery.
-```console
-Applying an application in vela K8s object format...
-I0516 15:45:18.123356 27156 apply.go:107] "creating object" name="first-vela-app" resource="core.oam.dev/v1beta1, Kind=Application"
-✅ App has been deployed 🚀🚀🚀
- Port forward: vela port-forward first-vela-app
- SSH: vela exec first-vela-app
- Logging: vela logs first-vela-app
- App status: vela status first-vela-app
- Endpoint: vela status first-vela-app --endpoint
-Application prod/first-vela-app applied.
-```
-
+
-* View the process and status of the application deployment
+## What You'll Learn
-```bash
-vela status first-vela-app
-```
+By following this getting started guide, you will:
-
-expected output
+- ✅ **Understand KubeVela basics** - Applications, Components, and Traits
+- ✅ **Deploy applications** - From simple to production-ready
+- ✅ **Manage environments** - Dev, staging, and production workflows
+- ✅ **Use the UI console** - Visual application management with VelaUX
+- ✅ **Implement best practices** - GitOps, multi-cluster, and more
-```console
-About:
+## Prerequisites
- Name: first-vela-app
- Namespace: prod
- Created at: 2022-05-16 15:45:18 +0800 CST
- Status: workflowSuspending
+- **For Standalone**: Any Linux, macOS, or Windows machine with 2 CPU cores and 4GB RAM
+- **For Kubernetes**: Existing cluster with Kubernetes 1.19+ and kubectl configured
-Workflow:
+## Getting Help
- ...
-
-Services:
-
- - Name: express-server
- Cluster: local Namespace: default
- Type: webservice
- Healthy Ready:1/1
- Traits:
- ✅ scaler
-```
-
-
-The application status will change to `workflowSuspending`, means the workflow has finished the first two steps and waiting for manual approval as per the step specified.
-
-* Access the application
-
-We can check the application by:
-
-```bash
-vela port-forward first-vela-app 8000:8000
-```
-
-It will invoke your browser and your can see the website:
-
-
-expected output
-
-```
-<, you can view and manage the application created.
-
-* Port forward the UI if you don't have endpoint for access:
- ```
- vela port-forward addon-velaux -n vela-system 8080:80
- ```
-
-* VelaUX need authentication, default username is `admin` and the password is **`VelaUX12345`**.
-
-It requires you to override with a new password for the first login, please make sure to remember the new password.
-
-* Check the resources deployed
-
-Click the application card, then you can view the details of the application.
-
-
-
-The UI console shares a different metadata layer with the controller. It's more like a PaaS architecture of a company which choose a database as the source of truth instead of relying on the etcd of Kubernetes.
-
-By default, if you're using CLI to manage the applications directly from Kubernetes API, we will sync the metadata to UI backend automatically. Once you deployed the application from the UI console, the automatic sync process will be stopped as the source of truth may be changed.
-
-:::tip
-If the namespace of the application operated by CLI has already been associated with the corresponding environment in UI, then the application will be automatically synchronized to the project associated with that environment in UI. Otherwise, the application will be synchronized to the default project.
-If you want to specify which project in UI console an application should be synchronized to, please refer to [Creating environments for the project](how-to/dashboard/user/project.md#creating-environments-for-the-project).
-:::
-
-If there're any changes happen from CLI after that, the UI console will detect the difference and show it for you. However, it's not recommended to modify the application properties from both sides.
-
-In conclusion, if you're a CLI/YAML/GitOps user, you'd better just use CLI to manage the application CRD and just use the UI console (velaux) as a dashboard. Once you've managed the app from the UI console, you need to align the behavior and manage apps from UI, API, or Webhook provided by velaux.
-
-## Clean up
-
-```bash
-vela delete first-vela-app
-```
-
-<details>
-<summary>expected output</summary>
-
-```console
-Deleting Application "first-vela-app"
-app "first-vela-app" deleted from namespace "prod"
-```
-</details>
-
-That's it! You succeed at the first application delivery. Congratulation!
-
-## Next Step
-
-- View [Core Concepts](./getting-started/core-concept.md) to learn more about how it works.
-- View [User Guide](./tutorials/webservice.mdx) to look on more of what you can achieve with KubeVela.
+- **[Documentation](../getting-started/core-concept)** - Comprehensive guides
+- **[Community Slack](https://slack.cncf.io/)** - Join #kubevela channel
+- **[GitHub Issues](https://github.com/kubevela/kubevela/issues)** - Report bugs or request features
+- **[YouTube Channel](https://www.youtube.com/channel/UCSCTHhGI5XJ0SEhDHVakPAA)** - Video tutorials
+- **[Explore Examples](https://github.com/kubevela/kubevela/tree/master/docs/examples)** - View the community curated examples
\ No newline at end of file
diff --git a/sidebars.js b/sidebars.js
index 4ad97aacbe4..2f0c7c3d88b 100644
--- a/sidebars.js
+++ b/sidebars.js
@@ -33,8 +33,36 @@ module.exports = {
],
},
{
- type: 'doc',
- id: 'quick-start',
+ type: 'category',
+ label: 'Getting Started with KubeVela',
+ collapsed: false,
+ items: [
+ {
+ type: 'doc',
+ id: 'quick-start',
+ label: 'Overview',
+ },
+ {
+ type: 'doc',
+ id: 'getting-started/quick-install',
+ label: 'Quick Install',
+ },
+ {
+ type: 'doc',
+ id: 'getting-started/first-application',
+ label: 'Deploy Your First App',
+ },
+ {
+ type: 'doc',
+ id: 'getting-started/advanced-application',
+ label: 'Deploy an Advanced App',
+ },
+ {
+ type: 'doc',
+ id: 'getting-started/first-component',
+ label: 'Creating Your First Component',
+ },
+ ],
},
],
},
diff --git a/versioned_docs/version-v1.10/getting-started/advanced-application.md b/versioned_docs/version-v1.10/getting-started/advanced-application.md
new file mode 100644
index 00000000000..c4972ce89a8
--- /dev/null
+++ b/versioned_docs/version-v1.10/getting-started/advanced-application.md
@@ -0,0 +1,429 @@
+---
+---
+title: Deploy an Advanced Application
+---
+
+Now that you've deployed your first application, let's explore some of KubeVela's more advanced features: multi-environment deployments, policies, and workflows with manual approval.
+
+## Prerequisites
+
+Before starting, make sure you have:
+- ✅ Completed [Deploy Your First Application](./first-application)
+- ✅ Basic understanding of KubeVela applications
+- ✅ KubeVela installed and running
+
+## Step 1: Understanding Advanced Concepts
+
+Before we begin, let's understand the new concepts we'll use:
+
+### What are Policies?
+
+Policies are rules that affect how and where your application is deployed. Think of them as _"deployment instructions"_, or application level modifiers, that can:
+- Control where your app runs (which cluster, namespace, region)
+- Modify configurations for different environments
+- Apply security or compliance rules
+- Set resource constraints
+
+**Common Policy Types:**
+- **Topology Policy**: Specifies **where** to deploy - like choosing which Kubernetes cluster and namespace
+- **Override Policy**: Modifies **how** components behave between environments - like using more replicas in production than dev
+- **Shared Resource Policy**: Allows sharing resources (like ConfigMaps or Secrets) across multiple applications
+- **Garbage Collection Policy**: Controls how resources are cleaned up when applications are updated or deleted
+
+> 📖 **Want to explore more?** See the [full list of available policies](https://kubevela.io/docs/end-user/policies/references/) in the reference documentation.
+
+### What are Workflows?
+
+Workflows orchestrate the deployment process through a series of steps. Instead of deploying everything at once, workflows let you:
+- Deploy in stages (dev → staging → production)
+- Add approval gates between environments
+- Run validation checks before proceeding
+- Rollback if something goes wrong
+
+**Common Workflow Steps:**
+- **Deploy Step**: Executes the actual deployment with selected policies
+- **Suspend Step**: Pauses and waits for manual approval
+- **Notification Step**: Sends alerts to Slack, email, webhooks, etc.
+- **Step Group**: Groups multiple steps to run in parallel
+
+> 📖 **Want to explore more?** See the [full list of workflow steps](https://kubevela.io/docs/end-user/workflow/built-in-workflow-defs/) in the reference documentation.
+
+### How Everything Works Together
+
+Building on the Components and Traits you learned in the [first application tutorial](./first-application), now we add:
+
+1. **Components** define *what* to deploy (your application) - [see available types](https://kubevela.io/docs/end-user/components/references/)
+2. **Traits** add operational *behaviors* to components (scaling, ingress, storage) - [see available traits](https://kubevela.io/docs/end-user/traits/references/)
+3. **Policies** define *where* to deploy and *how* to modify configurations per environment
+4. **Workflows** orchestrate *when* and *in what order* to deploy
+
+Here's how they work together in practice:
+
+1. You define a **Component** (like a web API) with **Traits** (like scaling to 2 replicas)
+2. You create **Policies** that specify different environments and configurations:
+ - Topology policy: "deploy to dev namespace"
+ - Override policy: "in production, scale to 5 replicas instead of 2"
+3. Your **Workflow** orchestrates the deployment:
+ - Step 1: Deploy to dev environment using dev policies
+ - Step 2: Wait for manual approval
+ - Step 3: Deploy to production using production policies (which override the scaling)
+
+The result: Same component and traits, but different behavior in each environment thanks to policies and workflows!
+
+## Step 2: Prepare the Environments
+
+First, let's create a production namespace:
+
+```bash
+vela env init prod --namespace prod
+```
+
+Expected output:
+```console
+environment prod with namespace prod created
+```
+
+Verify both environments exist:
+
+```bash
+vela env ls
+```
+
+## Step 3: Create the Advanced Application
+
+Save the following as `advanced-app.yaml`:
+
+```yaml
+apiVersion: core.oam.dev/v1beta1
+kind: Application
+metadata:
+ name: advanced-app
+ namespace: default
+spec:
+ components:
+ - name: backend-api
+ type: webservice
+ properties:
+ image: oamdev/hello-world
+ ports:
+ - port: 8000
+ expose: true
+ env:
+ - name: APP_ENV
+ value: "development"
+ traits:
+ - type: scaler
+ properties:
+ replicas: 1
+
+ policies:
+ # Development environment configuration
+ - name: env-development
+ type: topology
+ properties:
+ clusters: ["local"]
+ namespace: "default"
+
+ # Production environment configuration
+ - name: env-production
+ type: topology
+ properties:
+ clusters: ["local"]
+ namespace: "prod"
+
+ # Production-specific overrides
+ - name: production-configs
+ type: override
+ properties:
+ components:
+ - name: backend-api
+ properties:
+ env:
+ - name: APP_ENV
+ value: "production"
+ traits:
+ - type: scaler
+ properties:
+ replicas: 3 # Scale up for production
+
+ workflow:
+ steps:
+ # Step 1: Deploy to development
+ - name: deploy-to-dev
+ type: deploy
+ properties:
+ policies: ["env-development"]
+
+ # Step 2: Wait for manual approval
+ - name: manual-approval
+ type: suspend
+ properties:
+ message: "Please review the development deployment before promoting to production"
+
+ # Step 3: Deploy to production
+ - name: deploy-to-prod
+ type: deploy
+ properties:
+ policies: ["env-production", "production-configs"]
+```
+
+## Step 4: Understanding the Configuration
+
+Let's break down what this configuration does:
+
+### Components Section
+- Defines a `backend-api` web service
+- Sets initial configuration (1 replica, development environment variable)
+
+### Policies Section
+1. **`env-development`**: Deploys to default namespace
+2. **`env-production`**: Deploys to prod namespace
+3. **`production-configs`**: Overrides settings for production (3 replicas, production env var)
+
+### Workflow Section
+1. **`deploy-to-dev`**: First deployment to development
+2. **`manual-approval`**: Pauses for human review
+3. **`deploy-to-prod`**: Deploys to production with overrides
+
+## Step 5: Deploy the Application
+
+Start the deployment:
+
+```bash
+vela up -f advanced-app.yaml
+```
+
+Expected output:
+```console
+Applying an application in vela K8s object format...
+✅ App has been deployed 🚀🚀🚀
+ Port forward: vela port-forward advanced-app
+ SSH: vela exec advanced-app
+ Logging: vela logs advanced-app
+ App status: vela status advanced-app
+ Endpoint: vela status advanced-app --endpoint
+```
+
+## Step 6: Check Development Deployment
+
+The application will first deploy to development and then wait for approval:
+
+```bash
+vela status advanced-app -n default
+```
+
+Expected output:
+```console
+About:
+
+ Name: advanced-app
+ Namespace: default
+ Created at: 2025-10-22 09:11:31 +0100 IST
+ Healthy: ✅
+ Details: workflowSuspending
+
+Workflow:
+
+ mode: StepByStep-DAG
+ finished: false
+ Suspend: true
+ Terminated: false
+ Steps
+ - id: igp5mle4ze
+ name: deploy-to-dev
+ type: deploy
+ phase: succeeded
+ - id: frqtbqtalg
+ name: manual-approval
+ type: suspend
+ phase: suspending
+ message: Suspended by field suspend
+
+Services:
+
+ - Name: backend-api
+ Cluster: local
+ Namespace: default
+ Type: webservice
+ Health: ✅
+ Message: Ready:1/1
+ Traits:
+ Type: scaler
+ Health: ✅
+```
+
+## Step 7: Test Development Deployment
+
+Access the development deployment:
+
+```bash
+vela port-forward advanced-app -n default 8001:8000
+```
+
+Visit http://localhost:8001 to verify it's working.
+
+## Step 8: Approve Production Deployment
+
+Once you've verified the development deployment, approve the promotion to production:
+
+```bash
+vela workflow resume advanced-app
+```
+
+Expected output:
+```console
+Successfully resume workflow: advanced-app
+```
+
+## Step 9: Verify Production Deployment
+
+Check the full deployment status:
+
+```bash
+vela status advanced-app -n default
+```
+
+You should now see services in both environments:
+
+```console
+Services:
+ - Name: backend-api
+ Cluster: local
+ Namespace: prod
+ Type: webservice
+ Health: ✅
+ Message: Ready:3/3
+ Traits:
+ Type: scaler
+ Health: ✅
+
+ - Name: backend-api
+ Cluster: local
+ Namespace: default
+ Type: webservice
+ Health: ✅
+ Message: Ready:1/1
+ Traits:
+ Type: scaler
+ Health: ✅
+```
+
+## Step 10: Test Production Deployment
+
+Access the production deployment:
+
+```bash
+vela port-forward advanced-app -n prod 8002:8000
+```
+
+Visit http://localhost:8002 to verify production is working.
+
+## Step 11: Managing Workflow States
+
+### View Workflow History
+
+```bash
+vela workflow logs advanced-app
+```
+
+### Restart a Workflow
+
+If needed, you can restart the entire workflow:
+
+```bash
+vela workflow restart advanced-app -n default
+```
+
+### Rollback a Deployment
+
+To rollback to a previous version:
+
+```bash
+vela workflow rollback advanced-app -n default
+```
+
+## Clean Up
+
+Delete the application and environments:
+
+```bash
+# Delete the application
+vela delete advanced-app -n default
+
+# Remove the production environment
+vela env delete prod
+```
+
+## What You've Learned
+
+In this advanced tutorial, you:
+- ✅ Created multi-environment deployments
+- ✅ Implemented environment-specific configurations
+- ✅ Used workflow steps with manual approval
+- ✅ Applied policies for topology and overrides
+- ✅ Managed complex application lifecycles
+
+## Troubleshooting
+
+<details>
+<summary>Workflow stuck in suspended state</summary>
+
+Check the workflow status:
+```bash
+vela workflow logs advanced-app -n default
+```
+
+Resume if needed:
+```bash
+vela workflow resume advanced-app -n default
+```
+</details>
+
+<details>
+<summary>Production namespace not found</summary>
+
+Create it manually:
+```bash
+kubectl create namespace prod
+# or
+vela env init prod --namespace prod
+```
+</details>
+
+<details>
+<summary>Different replica counts not working</summary>
+
+Verify the override policy is correctly applied:
+```bash
+vela status advanced-app --tree -n default
+kubectl get deploy -n prod
+kubectl get deploy -n default
+```
+</details>
+
+## Next Steps
+
+Now that you've mastered advanced deployments:
+
+- **[Create Your First Component](./first-component)** - Learn how to build custom reusable components
+- **[Multi-Cluster Deployments](../../case-studies/multi-cluster)** - Deploy across multiple Kubernetes clusters
+- **[GitOps Integration](../../case-studies/gitops)** - Automate with Git workflows
+- **[Helm Integration](../../tutorials/helm)** - Deploy Helm charts as components
+
+### Explore Built-in Definitions
+
+- **[Component Types Reference](https://kubevela.io/docs/end-user/components/references/)** - All available component types
+- **[Traits Reference](https://kubevela.io/docs/end-user/traits/references/)** - All available traits
+- **[Policies Reference](https://kubevela.io/docs/end-user/policies/references/)** - All available policies
+- **[Workflow Steps Reference](https://kubevela.io/docs/end-user/workflow/built-in-workflow-defs/)** - All available workflow steps
+
+
+## Summary
+
+You've successfully deployed an advanced KubeVela application with:
+- Multiple environment configurations
+- Manual approval workflows
+- Environment-specific overrides
+- Production-ready patterns
+
+These patterns form the foundation for real-world application deployments with KubeVela.
\ No newline at end of file
diff --git a/versioned_docs/version-v1.10/getting-started/first-application.md b/versioned_docs/version-v1.10/getting-started/first-application.md
new file mode 100644
index 00000000000..0cca3e19014
--- /dev/null
+++ b/versioned_docs/version-v1.10/getting-started/first-application.md
@@ -0,0 +1,315 @@
+---
+title: Deploy Your First Application
+---
+
+In this guide, you'll deploy your first KubeVela application - a simple "Hello World" web service. This will help you understand the basic concepts and workflow.
+
+## Prerequisites
+
+Before starting, make sure you have:
+- ✅ [Installed KubeVela](quick-install)
+- ✅ Verified installation with `vela version`
+
+## Step 1: Understanding the Application Model
+
+Before diving into YAML, let's understand the core concepts:
+
+### What is an Application?
+
+An Application in KubeVela is a complete description of your microservice or system. It's the top-level resource that brings together all the pieces needed to run your software.
+
+### What are Components?
+
+Components are the building blocks of your application - they define **what** you want to deploy. A component encapsulates:
+- **Workloads**: Your actual running code (containers, functions, etc.)
+- **Resources**: Databases, message queues, cloud services
+- **Configurations**: Settings, environment variables, secrets
+
+Think of components as _"packaged units"_ of your application. For example:
+- A `webservice` component for your REST API
+- A `worker` component for background jobs
+- A `database` component for PostgreSQL
+
+Components are reusable and composable - you can use the same component type across different applications.
+
+### What are Traits?
+
+Traits are operational capabilities that you attach to components to add behaviors without changing the component itself. Think of them as _"plug-in features"_ that enhance your application:
+- **Scaling**: Control the number of replicas
+- **Ingress**: Expose your app to the internet
+- **Storage**: Attach persistent volumes
+- **Monitoring**: Add observability and metrics
+
+Traits are applied TO components. The same trait can work with different component types - for example, the `scaler` trait works with any deployable component.
+
+### How They Work Together
+
+```
+Application (online-store)
+├── Component: frontend (webservice)
+│ ├── Trait: scaler (replicas: 3)
+│ └── Trait: ingress (domain: store.example.com)
+└── Component: backend (webservice)
+ └── Trait: scaler (replicas: 2)
+```
+
+This separation of concerns means:
+- **Developers** focus on components (what to run)
+- **Operators** focus on traits (how to run it)
+- **Platform teams** can create reusable components and traits for everyone
+
+## Step 2: Create Your First Application
+
+Let's start with the simplest possible application - a web service:
+
+### Create the Application File
+
+Save the following as `hello-world.yaml`:
+
+```yaml
+apiVersion: core.oam.dev/v1beta1
+kind: Application
+metadata:
+ name: hello-world
+spec:
+ components:
+ - name: my-web-app
+ type: webservice
+ properties:
+ image: oamdev/hello-world
+ ports:
+ - port: 8000
+ expose: true
+```
+
+### What This Configuration Does
+
+**Application Metadata:**
+- **`apiVersion`**: Specifies the KubeVela API version
+- **`kind: Application`**: Declares this as a KubeVela Application
+- **`metadata.name`**: Names your application "hello-world"
+
+**Component Definition:**
+- **`type: webservice`**: Uses the built-in webservice component type
+- **`image`**: The container image to run
+- **`ports`**: Exposes port 8000 for access
+
+## Step 3: Deploy the Application
+
+Deploy your application with a single command:
+
+```bash
+vela up -f hello-world.yaml
+```
+
+You should see output like:
+```console
+Applying an application in vela K8s object format...
+✅ App has been deployed 🚀🚀🚀
+ Port forward: vela port-forward hello-world
+ SSH: vela exec hello-world
+ Logging: vela logs hello-world
+ App status: vela status hello-world
+ Endpoint: vela status hello-world --endpoint
+```
+
+## Step 4: Check Application Status
+
+Verify your application is running:
+
+```bash
+vela status hello-world
+```
+
+Expected output:
+```console
+About:
+
+ Name: hello-world
+ Namespace: default
+ Created at: 2025-10-22 09:00:52 +0100 IST
+ Healthy: ✅
+ Details: running
+
+...
+
+Services:
+ - Name: my-web-app
+ Cluster: local
+ Namespace: default
+ Type: webservice
+ Health: ✅
+ Message: Ready:1/1
+ No trait applied
+```
+
+## Step 5: Access Your Application
+
+Now let's see your app in action!
+
+```bash
+vela port-forward hello-world 8000:8000
+```
+
+This will:
+- Forward port 8000 from your application to your local machine
+- Automatically open your browser (on some systems)
+
+Navigate to http://localhost:8000 in your browser. You should see:
+
+```
+Hello KubeVela! Make shipping applications more enjoyable.
+```
+
+**Congratulations!** You've successfully deployed your first KubeVela application!
+
+## Step 6: Explore Your Application
+
+### View Logs
+
+Check what your application is doing:
+
+```bash
+vela logs hello-world
+```
+
+### Execute Commands
+
+Run commands inside your container:
+
+```bash
+vela exec hello-world -- ls -la
+```
+
+### List All Applications
+
+See all deployed applications:
+
+```bash
+vela ls
+```
+
+## Step 7: Add a Trait (Optional)
+
+Let's enhance your application by adding a scaling trait. Update your `hello-world.yaml`:
+
+```yaml
+apiVersion: core.oam.dev/v1beta1
+kind: Application
+metadata:
+ name: hello-world
+spec:
+ components:
+ - name: my-web-app
+ type: webservice
+ properties:
+ image: oamdev/hello-world
+ ports:
+ - port: 8000
+ expose: true
+ traits:
+ - type: scaler
+ properties:
+ replicas: 3
+```
+
+Apply the changes:
+
+```bash
+vela up -f hello-world.yaml
+```
+
+Check the status to see 3 replicas running:
+
+```bash
+vela status hello-world
+```
+
+## Step 8: Access the UI Console (Optional)
+
+If you installed VelaUX, you can manage your application visually:
+
+```bash
+# Port forward the UI
+vela port-forward addon-velaux -n vela-system 8080:80
+```
+
+Open http://localhost:8080 and login:
+- Username: `admin`
+- Password: `VelaUX12345` (you'll be prompted to change it)
+
+In the UI, you can:
+- View your application's topology
+- Inspect resources
+- Monitor health status
+- Make configuration changes
+
+## Clean Up
+
+When you're done experimenting:
+
+```bash
+vela delete hello-world
+```
+
+Confirm deletion:
+```console
+Start deleting application default/hello-world
+Delete application default/hello-world succeeded
+```
+
+## What You've Learned
+
+In this tutorial, you:
+- ✅ Created a KubeVela application configuration
+- ✅ Deployed a web service component
+- ✅ Accessed your running application
+- ✅ Added operational traits
+- ✅ Explored management commands
+- ✅ Used the UI console (optional)
+
+## Common Issues and Solutions
+
+<details>
+<summary>Application stuck in "rendering" status</summary>
+
+This usually means there's an issue with your configuration. Check:
+- YAML syntax is correct
+- Image name and tag exist
+- Port configuration is valid
+
+Run `vela status hello-world --tree` for detailed error messages.
+</details>
+
+<details>
+<summary>Port forwarding doesn't work</summary>
+
+Make sure:
+- The application is in "running" status
+- The port number matches your configuration
+- No other process is using port 8000
+
+Try a different local port: `vela port-forward hello-world 8080:8000`
+</details>
+
+<details>
+<summary>Can't access VelaUX</summary>
+
+Verify VelaUX is installed:
+```bash
+vela addon list | grep velaux
+```
+
+If not installed:
+```bash
+vela addon enable velaux
+```
+</details>
+
+## Next Steps
+
+Now that you've deployed your first application, you're ready to:
+
+- **[Deploy an Advanced Application](../advanced-application)** - Learn about multi-environment deployments
+- **[Understand Core Concepts](../core-concept)** - Deep dive into KubeVela's architecture
+- **[Explore Examples](https://github.com/kubevela/kubevela/tree/master/docs/examples)** - View the community curated examples
\ No newline at end of file
diff --git a/versioned_docs/version-v1.10/getting-started/first-component.md b/versioned_docs/version-v1.10/getting-started/first-component.md
new file mode 100644
index 00000000000..27e5bf834d8
--- /dev/null
+++ b/versioned_docs/version-v1.10/getting-started/first-component.md
@@ -0,0 +1,371 @@
+---
+title: Creating Your First Component
+---
+
+Learn how to create custom KubeVela components to package and reuse your application configurations.
+
+## Prerequisites
+
+Before starting, make sure you have:
+- ✅ Completed [Deploy Your First Application](first-application)
+- ✅ Basic understanding of YAML and Kubernetes concepts
+- ✅ KubeVela installed and running
+
+## What Are Components?
+
+Components in KubeVela are reusable building blocks that define your application workloads. While KubeVela provides built-in components like `webservice` and `worker`, you can create custom components for specific needs.
+
+## Step 1: Understanding Component Definitions
+
+In KubeVela, components are defined using CUE templates that can generate any type of Kubernetes resource. This flexibility allows you to capture a wide range of infrastructure and application needs:
+
+### Standard Kubernetes Workloads
+- **Deployments** - Stateless applications (web APIs, microservices)
+- **StatefulSets** - Stateful applications (databases, message queues)
+- **DaemonSets** - Node-level services (logging agents, monitoring)
+- **Jobs/CronJobs** - Batch processing and scheduled tasks
+
+### Cloud Resources
+- **Managed Databases** - RDS, CloudSQL, Azure Database
+- **Storage** - S3 buckets, blob storage, persistent volumes
+- **Networking** - Load balancers, VPCs, security groups
+- **Compute** - Virtual machines, serverless functions
+
+### Observability & Operations
+- **ServiceMonitor** - Prometheus monitoring configuration
+- **HorizontalPodAutoscaler** - Auto-scaling policies
+- **NetworkPolicy** - Security and traffic rules
+- **PodDisruptionBudget** - Availability guarantees
+
+### Custom Resources
+- **Istio Resources** - VirtualServices, DestinationRules
+- **Cert-Manager** - Certificate management
+- **FluxCD/ArgoCD** - GitOps resources
+- **Application-specific CRDs** - Your custom operators
+
+The CUE template defines a user-friendly schema (what parameters they configure) and generates the complex underlying Kubernetes manifests automatically.
+
+## Step 2: Create a Simple Custom Component
+
+Before starting, make sure you are using the default environment:
+```bash
+vela env set default
+```
+
+Let's create a super simple component that demonstrates the power of abstraction. We'll make a `my-simple-deployment` component that only requires an image and replicas - but generates all the Kubernetes YAML automatically.
+
+### Define the Component
+
+Create a file called `simple-deployment.cue`:
+
+```cue
+"my-simple-deployment": {
+ annotations: {}
+ attributes: {
+ workload: {
+ definition: {
+ apiVersion: "apps/v1"
+ kind: "Deployment"
+ }
+ type: "deployments.apps"
+ }
+ }
+ description: "Simple deployment with configurable image and replicas"
+ labels: {}
+ type: "component"
+}
+
+template: {
+ parameter: {
+ // Simple parameters - that's it!
+ image: string
+ replicas: *1 | int
+ }
+
+ // Generate the complex Deployment automatically
+ output: {
+ apiVersion: "apps/v1"
+ kind: "Deployment"
+ metadata: {
+ name: context.name
+ }
+ spec: {
+ replicas: parameter.replicas
+ selector: matchLabels: {
+ app: context.name
+ }
+ template: {
+ metadata: labels: {
+ app: context.name
+ }
+ spec: containers: [{
+ name: "main"
+ image: parameter.image
+ ports: [{
+ containerPort: 8080
+ }]
+ }]
+ }
+ }
+ }
+}
+```
+
+**What's powerful here:**
+- Users only need to specify `image` and `replicas`
+- KubeVela automatically generates labels, selectors, metadata, and container specs
+- The abstraction hides Kubernetes complexity while providing flexibility
+
+### Apply the Component Definition
+
+```bash
+vela def apply simple-deployment.cue
+```
+
+Verify it was created:
+
+```bash
+vela def list --type component
+```
+
+You should see `my-simple-deployment` in the list.
+
+## Step 3: Use Your Custom Component
+
+Now create an application using your custom component. Look how simple this is!
+
+Create `my-app.yaml`:
+
+```yaml
+apiVersion: core.oam.dev/v1beta1
+kind: Application
+metadata:
+ name: my-app
+spec:
+ components:
+ - name: my-simple-deployment-app
+ type: my-simple-deployment # Your custom component!
+ properties:
+ image: nginx:alpine
+ replicas: 3
+```
+
+**That's it!** Just 2 parameters, but it creates a complete Deployment with proper labels, selectors, and all the Kubernetes boilerplate.
+
+Deploy it:
+
+```bash
+vela up -f my-app.yaml
+```
+
+Check what was actually created:
+
+```bash
+vela status my-app --tree
+```
+
+You'll see KubeVela generated a full Deployment resource from your simple configuration!
+
+## Advanced: Enhancing Your Component with Status Evaluation
+
+Now let's enhance our `my-simple-deployment` component with advanced status evaluation features. This will give operators better visibility into the health of their deployments.
+
+Update your `simple-deployment.cue` file to include status evaluation:
+
+```cue
+"my-simple-deployment": {
+ annotations: {}
+ attributes: {
+ workload: {
+ definition: {
+ apiVersion: "apps/v1"
+ kind: "Deployment"
+ }
+ type: "deployments.apps"
+ }
+ status: {
+ healthPolicy: #"""
+ isHealth: (context.output.status.readyReplicas > 0) && (context.output.status.readyReplicas == context.output.status.replicas)
+ """#
+ customStatus: #"""
+ message: "Ready: \(context.output.status.readyReplicas)/\(context.output.status.replicas)"
+ """#
+ details: #"""
+ desiredReplicas: *context.output.status.replicas | 0
+ readyReplicas: *context.output.status.readyReplicas | 0
+ availableReplicas: *context.output.status.availableReplicas | 0
+ unavailableReplicas: *context.output.status.unavailableReplicas | 0
+ """#
+ }
+ }
+ description: "Simple deployment with configurable image and replicas"
+ labels: {}
+ type: "component"
+}
+
+template: {
+ parameter: {
+ // Simple parameters - that's it!
+ image: string
+ replicas: *1 | int
+ }
+
+ // Generate the complex Deployment automatically
+ output: {
+ apiVersion: "apps/v1"
+ kind: "Deployment"
+ metadata: {
+ name: context.name
+ }
+ spec: {
+ replicas: parameter.replicas
+ selector: matchLabels: {
+ app: context.name
+ }
+ template: {
+ metadata: labels: {
+ app: context.name
+ }
+ spec: containers: [{
+ name: "main"
+ image: parameter.image
+ ports: [{
+ containerPort: 8080
+ }]
+ }]
+ }
+ }
+ }
+}
+```
+
+**What's new in the enhanced component:**
+- **`healthPolicy`**: Defines when the component is considered healthy (all replicas are ready)
+- **`customStatus`**: Provides a custom status message showing ready vs total replicas
+- **`details`**: Exposes structured status information including conditions and replica counts
+
+### Apply the Enhanced Component
+
+Update your component definition:
+
+```bash
+vela def apply simple-deployment.cue
+```
+
+This will create a second revision of the component. You can view the revisions with:
+```bash
+kubectl get definitionrevision --all-namespaces | grep my-simple-deployment
+```
+
+Now redeploy your application to see the enhanced status features:
+
+```bash
+vela up -f my-app.yaml
+```
+
+Check the enhanced status information:
+
+```bash
+vela status my-app
+```
+
+Instead of needing multiple kubectl commands, they see:
+```
+About:
+
+ Name: my-simple-app
+ Namespace: default
+ Created at: 2025-10-22 11:41:17 +0100 IST
+ Healthy: ✅
+ Details: running
+
+...
+
+Services:
+ - Name: my-simple-deployment
+ Cluster: local
+ Namespace: default
+ Type: my-simple-deployment
+ Health: ✅
+ Message: Ready: 3/3
+ Status Details:
+ availableReplicas: 3
+ desiredReplicas: 3
+ readyReplicas: 3
+ unavailableReplicas: 0
+ No trait applied
+```
+
+**Key Benefits:**
+- **No Kubernetes expertise required** - Operators see application health, not infrastructure details
+- **Contextual information** - Only relevant status is surfaced
+- **Consistent interface** - Same `vela status` command works for any component type
+- **Actionable insights** - Clear messages about what's working or what needs attention
+
+## Troubleshooting
+
+<details>
+<summary>Component definition not found</summary>
+
+Check if the component is registered:
+```bash
+vela def list --type component
+vela def get <component-name> -t component
+```
+
+Re-apply if needed:
+```bash
+vela def apply your-component.cue
+```
+</details>
+
+<details>
+<summary>CUE syntax errors</summary>
+
+Validate your CUE template:
+```bash
+vela def vet your-component.cue
+```
+
+Check the rendered output:
+```bash
+vela dry-run -f your-app.yaml
+```
+</details>
+
+<details>
+<summary>Component not working with traits</summary>
+
+Ensure your component outputs the correct workload type:
+- Deployment for scaler, rollout traits
+- Service for ingress trait
+- Check trait requirements with `vela traits`
+</details>
+
+## What You've Learned
+
+In this tutorial, you:
+- ✅ Created custom component definitions
+- ✅ Used CUE templates to define component schemas
+- ✅ Deployed applications with custom components
+- ✅ Combined components with traits
+- ✅ Learned to package and share components
+
+## Next Steps
+
+This has given a brief introduction to writing custom definitions through CUE. For detailed information see:
+
+### CUE Fundamentals
+- **[CUE Basics](../../platform-engineers/cue/basic)** - Learn CUE language fundamentals
+- **[Definition Editing](../../platform-engineers/cue/definition-edit)** - CUE definition overview
+
+### Creating Custom Definitions
+- **[Custom Components](../../platform-engineers/components/custom-component)** - Build reusable component definitions
+- **[Custom Traits](../../platform-engineers/traits/customize-trait)** - Create operational behaviors
+- **[Custom Policies](../../platform-engineers/policy/custom-policy)** - Define deployment policies
+- **[Custom Workflows](../../platform-engineers/workflow/workflow)** - Build deployment pipelines
+
+### Advanced Features
+- **[External Packages](../../platform-engineers/cue/external-packages)** - Using external CUE packages
+- **[Component Health Status](../../platform-engineers/status/definition_health_status)** - Advanced status evaluation
+
diff --git a/versioned_docs/version-v1.10/getting-started/quick-install.md b/versioned_docs/version-v1.10/getting-started/quick-install.md
new file mode 100644
index 00000000000..bce3b5b3b5d
--- /dev/null
+++ b/versioned_docs/version-v1.10/getting-started/quick-install.md
@@ -0,0 +1,52 @@
+---
+title: Quick Install
+---
+
+Choose the installation method that best fits your environment:
+
+## Option A: Standalone (No Kubernetes Required)
+
+Perfect for beginners and local development. VelaD includes everything you need:
+
+```bash
+# Install VelaD (includes KubeVela + Kubernetes)
+curl -fsSl https://static.kubevela.net/script/install-velad.sh | bash
+
+# Start KubeVela with UI console
+velad install --set enableHA=false
+```
+
+> 📖 **Need more details?** See the full [Standalone Installation Guide](../installation/standalone) for platform-specific instructions.
+
+## Option B: Existing Kubernetes Cluster
+
+If you already have a Kubernetes cluster:
+
+```bash
+# Install the vela CLI
+curl -fsSl https://kubevela.io/script/install.sh | bash
+
+# Install KubeVela to your cluster
+vela install
+
+# Install the UI console (VelaUX)
+vela addon enable velaux
+```
+
+> 📖 **Need more details?** See the full [Kubernetes Installation Guide](../installation/kubernetes) for Helm installation and production configurations.
+
+## Verify Installation
+
+```bash
+vela version
+```
+
+You should see:
+```
+CLI Version: v1.10.x
+Core Version: v1.10.x
+```
+
+## Next Steps
+
+✅ Installation complete! Now continue to [Deploy Your First App](../getting-started/first-application).
\ No newline at end of file
diff --git a/versioned_docs/version-v1.10/quick-start.md b/versioned_docs/version-v1.10/quick-start.md
index 0bf913c8447..f145eb3d89f 100644
--- a/versioned_docs/version-v1.10/quick-start.md
+++ b/versioned_docs/version-v1.10/quick-start.md
@@ -1,269 +1,59 @@
---
-title: Deploy First Application
+title: Getting Started Overview
---
-:::note
-Before starting, please confirm that you've installed KubeVela and enabled the VelaUX addon according to [the installation guide](./install.mdx).
-:::
+Welcome to KubeVela! 🚀
-Welcome to KubeVela! This section will guide you to deliver your first app.
+This guide will walk you through everything you need to start using KubeVela, from installation to deploying advanced applications.
-## Deploy a classic application
+## Quick Start Path
-Below is a classic KubeVela application which contains one component with one operational trait, basically, it means to deploy a container image as webservice with one replica. Additionally, there are three policies and workflow steps, it means to deploy the application into two different environments with different configurations.
+Follow these steps in order to get up and running with KubeVela:
-```yaml
-apiVersion: core.oam.dev/v1beta1
-kind: Application
-metadata:
- name: first-vela-app
-spec:
- components:
- - name: express-server
- type: webservice
- properties:
- image: oamdev/hello-world
- ports:
- - port: 8000
- expose: true
- traits:
- - type: scaler
- properties:
- replicas: 1
- policies:
- - name: target-default
- type: topology
- properties:
- # The cluster with name local is installed the KubeVela.
- clusters: ["local"]
- namespace: "default"
- - name: target-prod
- type: topology
- properties:
- clusters: ["local"]
- # This namespace must be created before deploying.
- namespace: "prod"
- - name: deploy-ha
- type: override
- properties:
- components:
- - type: webservice
- traits:
- - type: scaler
- properties:
- replicas: 2
- workflow:
- steps:
- - name: deploy2default
- type: deploy
- properties:
- policies: ["target-default"]
- - name: manual-approval
- type: suspend
- - name: deploy2prod
- type: deploy
- properties:
- policies: ["target-prod", "deploy-ha"]
-```
+<div className="getting-started-cards">
-* Create an environment for your first app.
+### 1. 📦 [Quick Install](../getting-started/quick-install)
+Choose between standalone installation (no Kubernetes required) or installing on an existing cluster.
-```bash
-# This command will create a namespace in the local cluster
-vela env init prod --namespace prod
-```
+### 2. 🚀 [Deploy Your First App](../getting-started/first-application)
+Start with a simple "Hello World" application to learn the basics.
-<details>
-<summary>expected output</summary>
+### 3. 🏗️ [Deploy an Advanced App](../getting-started/advanced-application)
+Learn about multi-environment deployments, policies, and workflows.
-```console
-environment prod with namespace prod created
-```
-</details>
+### 4. 🔧 [Create Your First Component](../getting-started/first-component)
+Build custom reusable components for your applications.
-* Starting to deploy the application
+### 5. 📚 [Explore Tutorials](../tutorials/webservice)
+Discover tutorials, best practices, and advanced features.
-```
-vela up -f https://kubevela.net/example/applications/first-app.yaml
-```
+### 6. 📦 [Browse Examples](https://github.com/kubevela/kubevela/tree/master/docs/examples)
+View community curated examples and real-world use cases.
-<details>
-<summary>expected output</summary>
+### 7. 🤝 [Consider Contributing!](../contributor/overview)
+Join the KubeVela community and help shape the future of application delivery.
-```console
-Applying an application in vela K8s object format...
-I0516 15:45:18.123356 27156 apply.go:107] "creating object" name="first-vela-app" resource="core.oam.dev/v1beta1, Kind=Application"
-✅ App has been deployed 🚀🚀🚀
- Port forward: vela port-forward first-vela-app
- SSH: vela exec first-vela-app
- Logging: vela logs first-vela-app
- App status: vela status first-vela-app
- Endpoint: vela status first-vela-app --endpoint
-Application prod/first-vela-app applied.
-```
-</details>
+</div>
-* View the process and status of the application deployment
+## What You'll Learn
-```bash
-vela status first-vela-app
-```
+By following this getting started guide, you will:
-<details>
-<summary>expected output</summary>
+- ✅ **Understand KubeVela basics** - Applications, Components, and Traits
+- ✅ **Deploy applications** - From simple to production-ready
+- ✅ **Manage environments** - Dev, staging, and production workflows
+- ✅ **Use the UI console** - Visual application management with VelaUX
+- ✅ **Implement best practices** - GitOps, multi-cluster, and more
-```console
-About:
+## Prerequisites
- Name: first-vela-app
- Namespace: prod
- Created at: 2022-05-16 15:45:18 +0800 CST
- Status: workflowSuspending
+- **For Standalone**: Any Linux, macOS, or Windows machine with 2 CPU cores and 4GB RAM
+- **For Kubernetes**: Existing cluster with Kubernetes 1.19+ and kubectl configured
-Workflow:
+## Getting Help
- ...
-
-Services:
-
- - Name: express-server
- Cluster: local Namespace: default
- Type: webservice
- Healthy Ready:1/1
- Traits:
- ✅ scaler
-```
-</details>
-
-The application status will change to `workflowSuspending`, means the workflow has finished the first two steps and waiting for manual approval as per the step specified.
-
-* Access the application
-
-We can check the application by:
-
-```bash
-vela port-forward first-vela-app 8000:8000
-```
-
-It will invoke your browser and your can see the website:
-
-<details>
-<summary>expected output</summary>
-
-```
-<xmp>
-Hello KubeVela! Make shipping applications more enjoyable.
-
-...snip...
-```
-</details>
-
-* Resume the workflow
-
-After we finished checking the application, we can approve the workflow to continue:
-
-```bash
-vela workflow resume first-vela-app
-```
-
-<details>
-<summary>expected output</summary>
-
-```console
-Successfully resume workflow: first-vela-app
-```
-</details>
-
-Then the rest will be delivered in the `prod` namespace:
-
-```bash
-vela status first-vela-app
-```
-
-<details>
-<summary>expected output</summary>
-
-```console
-About:
-
- Name: first-vela-app
- Namespace: prod
- Created at: 2022-05-16 15:45:18 +0800 CST
- Status: running
-
-Workflow:
-
- ...snipt...
-
-Services:
-
- - Name: express-server
- Cluster: local Namespace: prod
- Type: webservice
- Healthy Ready:2/2
- Traits:
- ✅ scaler
- - Name: express-server
- Cluster: local Namespace: default
- Type: webservice
- Healthy Ready:1/1
- Traits:
- ✅ scaler
-```
-</details>
-
-Great! You have finished deploying your first KubeVela application, you can also view and manage it in UI.
-
-## Manage application with UI Console
-
-After finishing [the installation of VelaUX](./install.mdx#2-install-velaux), you can view and manage the application created.
-
-* Port forward the UI if you don't have endpoint for access:
- ```
- vela port-forward addon-velaux -n vela-system 8080:80
- ```
-
-* VelaUX need authentication, default username is `admin` and the password is **`VelaUX12345`**.
-
-It requires you to override with a new password for the first login, please make sure to remember the new password.
-
-* Check the resources deployed
-
-Click the application card, then you can view the details of the application.
-
-
-
-The UI console shares a different metadata layer with the controller. It's more like a PaaS architecture of a company which choose a database as the source of truth instead of relying on the etcd of Kubernetes.
-
-By default, if you're using CLI to manage the applications directly from Kubernetes API, we will sync the metadata to UI backend automatically. Once you deployed the application from the UI console, the automatic sync process will be stopped as the source of truth may be changed.
-
-:::tip
-If the namespace of the application operated by CLI has already been associated with the corresponding environment in UI, then the application will be automatically synchronized to the project associated with that environment in UI. Otherwise, the application will be synchronized to the default project.
-If you want to specify which project in UI console an application should be synchronized to, please refer to [Creating environments for the project](how-to/dashboard/user/project.md#creating-environments-for-the-project).
-:::
-
-If there're any changes happen from CLI after that, the UI console will detect the difference and show it for you. However, it's not recommended to modify the application properties from both sides.
-
-In conclusion, if you're a CLI/YAML/GitOps user, you'd better just use CLI to manage the application CRD and just use the UI console (velaux) as a dashboard. Once you've managed the app from the UI console, you need to align the behavior and manage apps from UI, API, or Webhook provided by velaux.
-
-## Clean up
-
-```bash
-vela delete first-vela-app
-```
-
-<details>
-<summary>expected output</summary>
-
-```console
-Deleting Application "first-vela-app"
-app "first-vela-app" deleted from namespace "prod"
-```
-</details>
-
-That's it! You succeed at the first application delivery. Congratulation!
-
-## Next Step
-
-- View [Core Concepts](./getting-started/core-concept.md) to learn more about how it works.
-- View [User Guide](./tutorials/webservice.mdx) to look on more of what you can achieve with KubeVela.
+- **[Documentation](../getting-started/core-concept)** - Comprehensive guides
+- **[Community Slack](https://slack.cncf.io/)** - Join #kubevela channel
+- **[GitHub Issues](https://github.com/kubevela/kubevela/issues)** - Report bugs or request features
+- **[YouTube Channel](https://www.youtube.com/channel/UCSCTHhGI5XJ0SEhDHVakPAA)** - Video tutorials
+- **[Explore Examples](https://github.com/kubevela/kubevela/tree/master/docs/examples)** - View the community curated examples
\ No newline at end of file
diff --git a/versioned_sidebars/version-v1.10-sidebars.json b/versioned_sidebars/version-v1.10-sidebars.json
index 77621f41e6f..393315c0a2f 100644
--- a/versioned_sidebars/version-v1.10-sidebars.json
+++ b/versioned_sidebars/version-v1.10-sidebars.json
@@ -31,8 +31,36 @@
]
},
{
- "type": "doc",
- "id": "quick-start"
+ "type": "category",
+ "label": "Getting Started with KubeVela",
+ "collapsed": false,
+ "items": [
+ {
+ "type": "doc",
+ "id": "quick-start",
+ "label": "Overview"
+ },
+ {
+ "type": "doc",
+ "id": "getting-started/quick-install",
+ "label": "Quick Install"
+ },
+ {
+ "type": "doc",
+ "id": "getting-started/first-application",
+ "label": "Deploy Your First App"
+ },
+ {
+ "type": "doc",
+ "id": "getting-started/advanced-application",
+ "label": "Deploy an Advanced App"
+ },
+ {
+ "type": "doc",
+ "id": "getting-started/first-component",
+ "label": "Creating Your First Component"
+ }
+ ]
}
]
},
]]>