Describe manual scaling and update page outline

Author: mocdaniel

content/en/docs/concepts/workloads/autoscaling.md

@@ -8,39 +8,92 @@ weight: 40
 
 <!-- overview -->
 
-The concept of _Autoscaling_ in Kubernetes refers to the ability to automatically update the available
-resources of your cluster. This can be either a replication controller (for example a
-{{< glossary_tooltip text="Deployment" term_id="deployment" >}} or
-{{< glossary_tooltip text="ReplicaSet" term_id="replica-set" >}}), or the cluster infrastructure
-itself (for example the number of {{< glossary_tooltip text="Nodes" term_id="node" >}}).
+In Kubernetes, you can _scale_ a workload depending on the current demand of resources.
+This allows your cluster to react to changes in resource demand more elastically and efficiently.
 
-Besides the differentiation in _what_ is being scaled, there are also different options for _how_ to scale:
+There are manual and automatic ways to scale your workloads, depending on your use case.
 
-- scale the number of available instances (such as Pods or Nodes)
-- scale the available resources on existing instances themselves (such as CPU or memory)
+<!-- body -->
+
+## Scaling workloads manually
+
+Kubernetes supports _manual scaling_ of workloads, either by changing the number of
+{{< glossary_tooltip text="Replicas" term_id="replica">}} of an object that manages a set of
+{{< glossary_tooltip text="Pods" term_id="pod" >}} (for example a {{< glossary_tooltip text="Deployment" term_id="deployment" >}}),
+or by adjusting the provided resources of each Replica (for example CPU or memory).
+
+### Scaling the number of Replicas of a workload
+
+You can use the `kubectl scale` command to increase or decrease the number of Replicas of a workload:
+
+```shell
+kubectl scale deployment <deployment-name> --replicas=<desired-replicas>
+```
+
+See also this [example of scaling a Deployment](/docs/concepts/workloads/controllers/deployment/#scaling-a-deployment) in the `Deployment` documentation.
+
+### Resizing workloads in-place
+
+Instead of scaling the number of Replicas of a workload, you can also adjust the provided resources
+of each Replica, in-place. You do this by patching the entries in one or both of the following
+fields of the `Pod` or [PodTemplate](/docs/concepts/workloads/pods/#pod-templates) you want to resize:
+
+- `spec.containers[*].resources.requests`
+- `spec.containers[*].resources.limits`
+
+{{< caution >}}
+Resizing a workload in-place **without** restarting the Pods or its Containers requires Kubernetes version 1.27 or later.
+{{< /caution >}}
+
+See also this task about [resizing CPU and memory resources](/docs/tasks/configure-pod-container/resize-container-resources) assigned to Containers.
+
+## Scaling workloads automatically
+
+Kubernetes also supports _automatic scaling_ of workloads, which is the focus of this page.
+
+The concept of _Autoscaling_ in Kubernetes refers to the ability to automatically update the workloads of your cluster. This can be either an object that manages a set of Pods (for example a
+{{< glossary_tooltip text="Deployment" term_id="deployment" >}} or Pods or PodTemplates themselves.
+
+Depending on _what_ is being scaled, there are also different options for _how_ to scale:
+
+- scale the number of available instances (such as Replicas in a Deployment)
+- scale the available resources on existing instances themselves (such as CPU or memory of a {{< glossary_tooltip text="Container" term_id="container" >}} in a Pod)
 
 The first option is referred to as _horizontal scaling_, while the second is referred to as _vertical scaling_.
 
-<!-- body -->
+### Scaling workloads horizontally
 
-## Scaling workloads horizontally
+In Kubernetes, you can automatically scale a workload horizontally using a _HorizontalPodAutoscaler_ (HPA).
 
-In Kubernetes, you can scale a workload horizontally using a _HorizontalPodAutoscaler_ (HPA).
 It is implemented as a Kubernetes API resource and a {{< glossary_tooltip text="controller" term_id="controller" >}}
-and periodically adjusts the number of {{< glossary_tooltip text="replicas" term_id="replica" >}}
+and periodically adjusts the number of {{< glossary_tooltip text="Replicas" term_id="replica" >}}
 in a workload to match observed resource utilization such as CPU or memory usage.
 
 There is a [walkthrough example](/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough) of configuring a HorizontalPodAutoscaler for a Deployment.
 
-## Scaling workloads vertically
+### Scaling workloads vertically
+
+_tbd_
+
+### Event driven Autoscaling
+
+_tbd_
+
+### Autoscaling based on cluster size
+
+_tbd_
+
+### Autoscaling based on schedules
+
+_tbd_
 
-_tba_ about VerticalPodAutoscaler
+## Scaling cluster infrastructure
 
-##
+_tbd_, short summary
 
-## Advanced Scenarios
+## Third-party Autoscalers
 
-_tba_ about Cluster Proportional Autoscaler, KEDA, and KNative Autoscaler
+_tbd_, short summary of KEDA and KNative autoscalers
 
 ## {{% heading "whatsnext" %}}