rename best practices (#2573)

* rename best practices

* adjust initializr

docs/components/best-practices/architecture/deciding-about-your-stack-c7.md

@@ -7,22 +7,22 @@ tags:
   - Application Server
   - Spring Boot
   - Maven
-description: "Camunda Platform 7 is very flexible and can be hooked into the architecture of your choice, giving you a number of important decisions to make."
+description: "Camunda 7 is very flexible and can be hooked into the architecture of your choice, giving you a number of important decisions to make."
 ---
 
-Camunda Platform 7 is very flexible and can be hooked into the architecture of your choice, giving you a number of important decisions to make. If you don't have special architecture requirements, we recommend following the proposed greenfield stack. You can also check the decision criteria presented below to make more customized choices. Choosing the stack will have big influence on your overall architecture.
+Camunda 7 is very flexible and can be hooked into the architecture of your choice, giving you a number of important decisions to make. If you don't have special architecture requirements, we recommend following the proposed greenfield stack. You can also check the decision criteria presented below to make more customized choices. Choosing the stack will have big influence on your overall architecture.
 
-:::caution Camunda Platform 7 only
-This best practice targets Camunda Platform 7.x only! If you look for Camunda Platform 8, please refer to [Deciding about your Camunda Platform 8 stack](../deciding-about-your-stack/).
+:::caution Camunda 7 only
+This best practice targets Camunda 7.x only! If you look for Camunda 8, please refer to [Deciding about your Camunda 8 stack](../deciding-about-your-stack/).
 :::
 
 ## The Java greenfield stack
 
-The greenfield stack is pretty similar for various languages. This section described the currently a recommendation for Java developers. If you use different programming languages (like .NET or JavaScript), we recommend looking at Camunda Platform 8, which supports polyglott environments better. The greenfield recommendation has recently changed. So if the recommendation below is surprising to you, you might want to check [this blog post](https://blog.bernd-ruecker.com/moving-from-embedded-to-remote-workflow-engines-8472992cc371).
+The greenfield stack is pretty similar for various languages. This section described the currently a recommendation for Java developers. If you use different programming languages (like .NET or JavaScript), we recommend looking at Camunda 8, which supports polyglott environments better. The greenfield recommendation has recently changed. So if the recommendation below is surprising to you, you might want to check [this blog post](https://blog.bernd-ruecker.com/moving-from-embedded-to-remote-workflow-engines-8472992cc371).
 
 Use the following stack:
 
-1. Leverage the [Camunda Run](https://docs.camunda.org/manual/latest/installation/camunda-bpm-run/) distribution to run Camunda Platform 7 using the [Enterprise Edition](https://camunda.com/download/enterprise/), preferrably [via Docker](https://docs.camunda.org/manual/latest/user-guide/camunda-bpm-run/#starting-camunda-platform-run-using-docker).
+1. Leverage the [Camunda Run](https://docs.camunda.org/manual/latest/installation/camunda-bpm-run/) distribution to run Camunda 7 using the [Enterprise Edition](https://camunda.com/download/enterprise/), preferably [via Docker](https://docs.camunda.org/manual/latest/user-guide/camunda-bpm-run/#starting-camunda-platform-run-using-docker).
 
 1. Build your process solution project as a [Spring Boot](https://spring.io/projects/spring-boot) application, using the [Camunda 4 REST Client for Spring Boot](https://github.com/camunda-community-hub/camunda-engine-rest-client-java/).
 
@@ -62,21 +62,21 @@ one_ greenfield recommendation for all our customers who have no special require
 We decided on this stack for the following reasons:
 
 - All components are open source and easily available.
-- Camunda Run is the favorite distribution, as it focuses on external tasks, the more modern paradigm also present in Camunda Platform 8.
+- Camunda Run is the favorite distribution, as it focuses on external tasks, the more modern paradigm also present in Camunda 8.
 - Spring Boot is currently the most adopted way of building Java applications.
 - Spring Boot applications are easy to customize as well as easy to roll out into test and production environments, either on-premise or in the cloud.
 - PostgreSQL has a great track-record for performance.
 
 There are several _advantages using the greenfield stack_:
 
-- _Fewer decisions:_ Depending on your experience with the Java cosmos, the decisions to chose a stack might not be easy to take. So if you don't have special requirements, follow a well-known path.
+- _Fewer decisions:_ Depending on your experience with the Java cosmos, the decisions to choose a stack might not be easy to take. So if you don't have special requirements, follow a well-known path.
 - _Proven:_ Many of our customers use this stack with great success.
 - _More documentation & Best Practices:_ You don't have to write your own extensive documentation, just point to the Camunda docs.
 - _Easier support:_ Asking for help gets much easier as you do not have to explain your setup in detail.
 
-### Considering Camunda Platform 8 instead
+### Considering Camunda 8 instead
 
-Camunda Platform 8 is an alternative process automation offering that catches up on funcationality quickly. For new projects, consider using Camunda Platform 8 from the start. You can find [a quick comparison of concepts in the docs](/guides/migrating-from-camunda-7/conceptual-differences.md). Note that architecturally, the recommended greenfield stack in this best practice is close to what you do using Camunda Platform 8.
+Camunda 8 is an alternative process automation offering that catches up on functionality quickly. For new projects, consider using Camunda 8 from the start. You can find [a quick comparison of concepts in the docs](/guides/migrating-from-camunda-7/conceptual-differences.md). Note that architecturally, the recommended greenfield stack in this best practice is close to what you do using Camunda 8.
 
 ### Getting started with the greenfield stack
 
@@ -94,7 +94,7 @@ Check the **prerequisites**:
 
 Create your **development project**
 
-1. Create a new Spring Boot project (e.g. using [Spring initializr](https://start.spring.io/))
+1. Create a new Spring Boot project (e.g. using [Spring Initializr](https://start.spring.io/))
 2. Add the dependency for the [Camunda Engine OpenAPI REST Client](https://github.com/camunda-community-hub/camunda-engine-rest-client-java/) community extension:
 
 ```
@@ -188,7 +188,7 @@ When running an embedded engine, you may want to use a Camunda web application l
 
 ### Choosing a database
 
-Camunda Platform 7 requires a _relational database_ for persistence. Even if the persistence provider is in theory pluggable and can be exchanged by e.g. some _NoSQL_ persistence this is neither recommended nor supported. Therefore, if you have use cases for this, discuss them with Camunda beforehand!
+Camunda 7 requires a _relational database_ for persistence. Even if the persistence provider is in theory pluggable and can be exchanged by e.g. some _NoSQL_ persistence this is neither recommended nor supported. Therefore, if you have use cases for this, discuss them with Camunda beforehand!
 
 |                                | PostgreSQL                                                       | Oracle                                                             | H2                                                                   | Other databases                                                                                                  |
 | ------------------------------ | ---------------------------------------------------------------- | ------------------------------------------------------------------ | -------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |

docs/components/best-practices/architecture/deciding-about-your-stack.md

@@ -11,23 +11,23 @@ tags:
 
 If you don't have special architecture requirements, we recommend using SaaS following the proposed greenfield stack.
 
-:::caution Camunda Platform 8
-This best practice targets Camunda Platform 8 only! If you look for Camunda Platform 7, please refer to [Deciding about your Camunda 7 stack](../deciding-about-your-stack-c7/).
+:::caution Camunda 8
+This best practice targets Camunda 8 only! If you look for Camunda 7, please refer to [Deciding about your Camunda 7 stack](../deciding-about-your-stack-c7/).
 :::
 
 ## The greenfield stack
 
 We like to give one greenfield stack recommendation, which is the stack you can simply use if there is no reason against it. And while we went through long and detailed discussions to come to this recommendation, it _doesn't_ mean that it is necessarily superior to alternative stacks. You can still feel confident if you go down another route (note below for alternative options).
 
-The stack looks pretty similar in various programming language. Please use the programnming language your team is most familiar with. If in doubt, use Java or JavaScript.
+The stack looks pretty similar in various programming language. Please use the programming language your team is most familiar with. If in doubt, use Java or JavaScript.
 
 ### The Java greenfield stack
 
 ![greenfield stack architecture diagram](deciding-about-your-stack-assets/greenfield-architecture.png)
 
 Use the following stack:
 
-1. Use [Camunda Platform 8 SaaS](https://signup.camunda.com/accounts?utm_source=docs.camunda.io&utm_medium=referral) and create a cluster there
+1. Use [Camunda 8 SaaS](https://signup.camunda.com/accounts?utm_source=docs.camunda.io&utm_medium=referral) and create a cluster there
 
 1. Build your process solution project as a [Spring Boot](https://spring.io/projects/spring-boot) application, using the [Spring Zeebe](/docs/apis-tools/community-clients/spring.md).
 
@@ -68,11 +68,11 @@ You can develop process solutions as described with Java above also in any other
 
 ## Customize your stack
 
-### Running Camunda Platform 8 self-managed
+### Running Camunda 8 self-managed
 
-You can also run Camunda Platform 8 self-managed on your own Kubernetes cluster. Details can be found in the [deployment docs](../../../self-managed/platform-deployment/overview.md).
+You can also run Camunda 8 self-managed on your own Kubernetes cluster. Details can be found in the [deployment docs](../../../self-managed/platform-deployment/overview.md).
 
-While there [exists a Docker Compose configuration](/docs/self-managed/platform-deployment/docker/) to run Camunda Platform 8 locally, this is not meant to be used for production, but rather to quickly startup components on a developer machine to be able to play around.
+While there [exists a Docker Compose configuration](/docs/self-managed/platform-deployment/docker/) to run Camunda 8 locally, this is not meant to be used for production, but rather to quickly startup components on a developer machine to be able to play around.
 
 ### Modeling for executable processes
 

docs/components/best-practices/architecture/extending-human-task-management-c7.md

@@ -9,8 +9,8 @@ tags:
   - Overdue Task
 ---
 
-:::caution Camunda Platform 7 only
-This best practice targets Camunda Platform 7.x only and is an appendum to [understanding human task management](../understanding-human-tasks-management/).
+:::caution Camunda 7 only
+This best practice targets Camunda 7.x only and is an appendum to [understanding human task management](../understanding-human-tasks-management/).
 :::
 
 ## The Camunda 7 task lifecyle
@@ -19,7 +19,7 @@ Do not show the _lifecycle_ of user _tasks_ in the process model, they are gener
 
 ![Task lifecycle](extending-human-task-management-c7-assets/task-lifecycle.png)
 
-- Create: New tasks are normally created as part of _process execution_, but can be created by an _user action_, too (as standalone tasks). `taskService.newTask()`
+- Create: New tasks are normally created as part of _process execution_, but can be created by a _user action_, too (as standalone tasks). `taskService.newTask()`
 - Set Candidate: Typically candidates are initially set to _groups_ of people as part of _process execution_, but can be requested by API, too. `taskService.addCandidateGroup(taskId, groupId)`
 - Claim: Individual members of a candidate group _assign themselves_ to tasks when working on them.`taskService.claim(taskId, userId)`
 - Unclaim: Individual assignees _unassign themselves_ and move a task back to the candidates.`taskService.claim(taskId, null)`

docs/components/best-practices/architecture/sizing-your-environment-c7.md

@@ -6,13 +6,13 @@ tags:
   - Performance
   - Hardware
   - Sizing
-description: "Size your environment for Camunda Platform 7, including sufficient hardware and database space. This best practice targets Camunda Platform 7.x only."
+description: "Size your environment for Camunda 7, including sufficient hardware and database space. This best practice targets Camunda 7.x only."
 ---
 
-Size your environment for Camunda Platform 7 appropriately, including sufficient hardware and database space.
+Size your environment for Camunda 7 appropriately, including sufficient hardware and database space.
 
-:::caution Camunda Platform 7 only
-This best practice targets Camunda Platform 7.x only! If you are using Camunda Platform 8, visit [Sizing your Camunda Platform 8 Environment](../sizing-your-environment/).
+:::caution Camunda 7 only
+This best practice targets Camunda 7.x only! If you are using Camunda 8, visit [Sizing your Camunda 8 Environment](../sizing-your-environment/).
 :::
 
 ## Understanding the influencing factors
@@ -44,7 +44,7 @@ From the Camunda perspective, there are a number of aspects to look at:
 
 We normally do not hit limits in scalability of Camunda. Due to the small footprint, the engine can run with extreme efficiency. All state is persisted in the database, so you can always add new process engine instances (e.g. cluster nodes) to speed up execution.
 
-The natural limit for this kind of architecture is the database. More scalability can be achieved using [Camunda Platform 8](https://camunda.com/products/cloud/).
+The natural limit for this kind of architecture is the database. More scalability can be achieved using [Camunda 8](https://camunda.com/products/cloud/).
 
 ### High availability