<!-- llms-index: https://docs.gradle.com/develocity/llms.txt -->

<a id="component-eol-banner"></a>

You are viewing **Develocity Documentation 2025.3**. To view the latest available version of the docs, see [2026.1](https://docs.gradle.com/develocity/2026.1/installation/standalone-installation/).

# Self-Hosted Standalone Installation Guide

<a id="preamble"></a>

This guide covers the installation of [Develocity](https://gradle.com/develocity/) into a single host.

Develocity is a Kubernetes-based application, distributed as a [Helm](https://helm.sh/) chart. Helm is a package manager for Kubernetes applications. The standalone installation of Develocity described in this guide involves installing the [K3s](https://k3s.io/) lightweight Kubernetes distribution onto a host, then using Helm to install Develocity in the K3s instance on that host. [Helm](https://helm.sh/docs/intro/using_helm/) manages all Develocity components.

For instructions on installing Develocity on a host without public network connectivity, see [Airgap Installation](#airgap_install).

<a id="prerequisites"></a>

## Prerequisites

This section lists the items required before beginning the installation.

<a id="get_license"></a>

### Develocity License

If you have purchased Develocity or started a trial, you should already have a license file called `develocity.license`. Otherwise, you may [request a Develocity trial license](https://gradle.com/develocity/trial/).

<a id="host-requirements"></a>

## Host Requirements

This section outlines the host requirements for the installation.

<a id="os_requirements"></a>

### 1. Operating System

Develocity is expected to work on most modern Linux systems. The operating system requirements are mainly the same as those for the used [K3s Kubernetes distribution](https://docs.k3s.io/installation/requirements#operating-systems).

> [!NOTE]
> Currently, Develocity only supports the x86\_64 architecture.

* * *

<a id="k3s"></a>

### 2. K3s

[K3s](https://docs.k3s.io/installation/requirements#networking) needs several ports to be accessible from the host.

 
| Protocol | Port |
| --- | --- |
| TCP | 6443 |
| TCP | 10250 |
| UDP | 8472 |

While these ports don’t need to be accessible from outside the host machine, K3s may access them using a different network interface or non-localhost IP.

<a id="rehl_k3s_requirements"></a>

#### RHEL / CentOS Stream

On Red Hat Enterprise Linux and CentOS Stream hosts, if `nm-cloud-setup` is enabled, you must disable the service and reboot the system.

🔍 **Disable `nm-cloud-setup.service`**

First, check if the `nm-cloud-setup.service` is enabled on your system:

```shell
sudo systemctl is-enabled nm-cloud-setup.service
```

If the service is disabled, the command returns _disabled_, otherwise it returns _enabled_.  
If `nm-cloud-setup` is enabled, disable it with the following command:

```shell
sudo systemctl disable nm-cloud-setup.service nm-cloud-setup.timer
```

Reboot the system:

```shell
sudo systemctl reboot
```

Disabling `firewalld` is recommended, too. If you can’t, ensure that the ports mentioned above are accessible and enable IP address masquerading. This can be done with the following command:

```shell
firewall-cmd --add-masquerade --permanent
```

For more details on IP address masquerading, see [RedHat’s docs](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/7/html/security_guide/sec-configuring_ip_address_masquerading).  
For more details on the RHEL / CentOS requirements, see [K3s’s docs](https://docs.k3s.io/installation/requirements?_highlight=centos#operating-systems).

<a id="cpu_memory"></a>

### 3. CPU & Memory

The minimum installation requirements are:

*   **10** CPUs (`x86_64` architecture)
    
*   **24** GiB of memory
    

<a id="database"></a>

### 4. Database

By default, Develocity stores its data in a **PostgreSQL** database that is run as part of the application itself, with data being stored in a directory mounted on its host machine.

Develocity installations have two database options:

1.  An **embedded database** that is highly dependent on disk performance.
    
2.  A **user-managed database** can be any PostgreSQL database compatible with versions 14 through 17.
    

> [!NOTE]
> Using [PgBouncer](https://www.pgbouncer.org/) with a user managed database is not supported.

<a id="storage"></a>

### 5. Storage

In addition to the database, Develocity needs storage capacity for configuration files, logs, Build Cache artifacts, and database backups. To simplify managing disk space, Gradle recommends mounting separate persistent storage volumes for data, logs, and backups.

<a id="storage_requirements_capacity"></a>

#### Capacity

<a id="user_managed_database"></a>

By default, Develocity stores its data under `/opt/gradle`. Each subdirectory can be remounted to a separate persistent volume via `global.storage.*` Helm values. It’s recommended to create a dedicated volume for the installation directory and to ensure **at least 10% of the volume’s space is free at all times**.

   
| Location | Helm Value | Minimum Size | Notes |
| --- | --- | --- | --- |
| /opt/gradle | global.storage.directory | 250 GB (embedded DB) / 30 GB (user-managed DB) | Application data, Build Cache, and embedded database. Requires SSD performance. The user-managed DB minimum excludes Build Cache data — provision more if Build Cache is stored locally. |
| /opt/gradle/logs | global.storage.logs.directory | 10 GB | Application logs. |
| /opt/gradle/backups | global.storage.backup.directory | 250 GB | Database backups. Applicable only when using the embedded database. |
| /var/lib/rancher/k3s | — | 30 GB | K3s runtime. Not performance-sensitive. |

If you are producing many Build Scan results in a day (> 1 GB) or intend to retain Build Scan data for long periods of time (30 days+), consider provisioning more storage for the data volume.

If your storage class doesn’t allow expanding volumes, prepare for future data growth by adding additional disk capacity upfront.

<a id="storage_performance"></a>

#### Performance

<a id="embedded_database_performance"></a>

For production workloads, storage volumes should exhibit SSD-class disk performance of at least **3000 IOPS** (input/output operations per second). Most NFS based storage or desktop-class, non-SSD disk drives don’t provide this level of performance.

> [!NOTE]
> Disk performance has a significant impact on Develocity performance. Network file systems (such as Amazon EFS) aren’t compatible with Develocity due to their performance characteristics.

<a id="object_storage"></a>

#### Object Storage

Develocity administrators can store Build Scan® data and monitoring data such as metrics in an object storage service, such as [Amazon S3](https://aws.amazon.com/s3/), [Google Cloud Storage](https://cloud.google.com/storage), and [Microsoft Azure Blob Storage](https://azure.microsoft.com/en-us/products/storage/blobs). This can help performance in high-traffic installations by reducing the load on the database. Object storage services offer performance and cost advantages compared to database storage. If you deploy Develocity to a cloud provider or have an available internal S3-compatible object store, Gradle recommends using object-based storage for your installation. See [Build Scan object storage](https://docs.gradle.com/develocity/2025.3/administration/admin-manual/#build_scan_object_storage) in the Develocity Administration Manual for a description of the benefits and limitations.

<a id="6-network-connectivity"></a>

### 6. Network Connectivity

Develocity requires network connectivity for periodic license validation.

> [!WARNING]
> An installation of Develocity will not start if it cannot connect to both `registry.gradle.com` and `harbor.gradle.com`.

It is strongly recommended that production installations of Develocity are configured to use HTTPS with a trusted certificate.

Verify that your DNS points to your Develocity instance.

```
develocity.example.com A 12.34.56.78
```

You should verify that your DNS record works correctly before installing Develocity by running `dig develocity.example.com` or `ping develocity.example.com` in a console window.

**For Airgap installations, you will need a temporary machine that can access the internet to download installation files. You will need to transfer those files from the machine to your Develocity host of choice.**

<a id="installing_gradle_enterprise"></a>

## Installation

In this section you will install Develocity on your host.

**For those installing Develocity on a host without public network connectivity, follow the [Airgap installation instructions](#airgap_install).**

<a id="1-copy-files"></a>

### 1. Copy Files

Make sure that your Develocity license file is available on your host machine.

<a id="online_k3s_installation"></a>

### 2. Install K3s

Install K3s and make it available to the current user:

```shell
curl -sfL https://get.k3s.io | sh -
```

```shell
sudo chown $UID /etc/rancher/k3s/k3s.yaml
```

```shell
mkdir -p "${HOME}/.kube"
```

```shell
ln -sf /etc/rancher/k3s/k3s.yaml "${HOME}/.kube/config"
```

Verify that you can interact with the K3s cluster:

```shell
kubectl get namespace
```

The expected output should be similar to this:

**Output:**

```
NAME                STATUS   AGE
default             Active   1h
kube-system         Active   1h
kube-public         Active   1h
kube-node-lease     Active   1h
```

> [!TIP]
> For more information on K3s installation, see the K3s [Quick-Start Guide](https://docs.k3s.io/quick-start) and K3s [Installation](https://docs.k3s.io/installation).

<a id="online_helm_installation"></a>

### 3. Install Helm

Develocity requires **Helm version 3.13.x (or later)** to install.

It is recommended to use the latest version available as this will have all known security vulnerabilities addressed. [This document](https://helm.sh/docs/topics/version_skew/) describes the maximum version skew supported between Helm and Kubernetes.

> [!TIP]
> For more information on installing Helm (including alternate installation approaches), see [Installing Helm](https://helm.sh/docs/intro/install/).

Install Helm with the following command:

```shell
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
```

> [!NOTE]
> This guide covers installation of the `gradle-enterprise-standalone` chart. Installation of the `gradle-enterprise` chart is covered in the [Self-Hosted Kubernetes Installation Guide](https://docs.gradle.com/develocity/2025.3/installation/kubernetes-installation/).

<a id="helm_config"></a>

### 4. Prepare a Helm Values File

<a id="values_yaml"></a>

Installation options for Develocity are depicted in a Helm values file.

Follow the instructions in the [Standalone Helm Chart Configuration Guide](https://docs.gradle.com/develocity/2025.3/reference/standalone-chart/) and return to this document with a complete `values.yaml` file.

<a id="repo"></a>

### 5. Install the Helm Chart

Develocity is distributed from the [Develocity Helm repository](https://helm.gradle.com/).

Add the Develocity Helm repository to your Helm installation and fetch its contents into the local cache:

```shell
helm repo add gradle https://helm.gradle.com/
```

```shell
helm repo update gradle
```

Verify that the Develocity chart is accessible:

```shell
helm search repo gradle-enterprise
```

This will report the latest versions available for the two Develocity charts:

**Output:**

```
NAME                                CHART VERSION       APP VERSION         DESCRIPTION
gradle/gradle-enterprise            2025.3.3      2025.3.3      Official Develocity chart for Kubernetes cluster installations
gradle/gradle-enterprise-standalone	2025.3.3      2025.3.3      Official Develocity chart for standalone installations
```

<a id="install_develocity"></a>

### 6. Install Develocity

Install Develocity by running:

```shell
helm install \
  --create-namespace --namespace develocity \(1)
  ge-standalone \(2)
  gradle/gradle-enterprise-standalone \(3)
  --values values.yaml \(4)
  --set-file global.license.file=./develocity.license (5)
```

1. This example uses develocity as the namespace, but it can be a custom name. If you use a custom name, update all other example commands accordingly.
2. This is the Helm release name. It is used by Helm to identify the Develocity installation.
3. The Develocity chart to install, in this case, gradle/gradle-enterprise-standalone.To install a specific version, use --version 2025.3.3.
4. The Helm values file with configuration values, including items such as the hostname.
5. The Develocity license file (if not already included in values file).

<a id="start"></a>

### 7. Start Develocity

At this point, it should be possible to see the Helm release installed:

```shell
helm list --namespace develocity
```

**Output:**

```
NAME            NAMESPACE           REVISION  UPDATED         STATUS    CHART                                  APP VERSION
ge-standalone   develocity          1         2025-11-11      deployed  gradle-enterprise-standalone-2025.3.3  2025.3.3
```

You can inspect the status of the Develocity Pods:

```shell
kubectl get pods --namespace develocity
```

**Output:**

```
NAME                                               READY   STATUS    RESTARTS        AGE
gradle-database-58f97cc888-sscxn                   2/2     Running   0               3m39s
gradle-embedded-object-storage-68d8956f98-c7gs9    1/1     Running   0               3m39s
gradle-enterprise-app-7fc5966df8-dw55g             1/1     Running   0               3m39s
gradle-enterprise-operator-dc7dbf46d-pp5hf         1/1     Running   0               3m39s
gradle-keycloak-5b975c469f-vw7ts                   1/1     Running   0               3m39s
gradle-metrics-d8f8f4557-fxdwj                     2/2     Running   0               3m39s
gradle-monitoring-5f97675474-dszqv                 3/3     Running   0               3m38s
gradle-node-monitoring-7c4744dd6c-jmxkx            1/1     Running   0               3m39s
gradle-proxy-5c49c559ff-96w4q                      1/1     Running   0               3m39s
gradle-test-distribution-broker-77957b5988-5x5ph   1/1     Running   0               3m39s
```

Develocity has a `/ping` endpoint, which can be used to verify network connectivity with Develocity.

Connectivity to Develocity installation can be tested by running the following command on machines which need to connect to Develocity:

```shell
curl -sw \\n --fail-with-body --show-error https://develocity.example.com/ping
```

It should return `SUCCESS`.

Once all Pods have a status of `Running` and the system is up and connected, you can interact with Develocity by visiting its URL in a web browser (i.e. the hostname).

![Develocity Sign in Page of Your Instance](https://docs.gradle.com/develocity/2025.3/installation/standalone-installation/../_images/gradle-enterprise.png)

Develocity Sign in Page of Your Instance

**Congratulations Develocity is installed and running.**

Head over to the [Next Steps](#next_steps) section to learn more about Develocity.

<a id="airgap_install"></a>

## Airgap Installation

In an airgap installation, the container images are preloaded into K3s. Helm is then configured so that no attempt is made to pull images from the outside world.

Airgap installations require a specific entitlement on your license. Please contact Gradle if you need an Airgap-enabled license.

Airgap installation involves downloading files, transferring them, installing supporting software, and running `helm install`.

> [!NOTE]
> When installing Develocity, follow the installation manual for that version as the steps may have changed. See [Develocity releases](https://gradle.com/develocity/releases/) for information about the available versions.

We recommend you save all the files into a single **transfer directory**, so that it’s effortless to transfer to the host where you are installing Develocity. For example:

```shell
mkdir develocity-files && cd develocity-files
```

<a id="1-download-required-files"></a>

### 1. Download Required Files

<a id="1-1-download-k3s"></a>

#### 1.1 Download K3s

Use the [version overview matrix](https://docs.gradle.com/develocity/2025.3/miscellaneous/compatibility/#kubernetes_and_helm) to identify the latest version of K3s supported by your version of Develocity.

Download the K3s images, binary, and install script:

```shell
curl -LO https://github.com/k3s-io/k3s/releases/download/v1.34.6+k3s1/k3s
```

```shell
curl -LO \
  https://github.com/k3s-io/k3s/releases/download/v1.34.6%2Bk3s1/k3s-airgap-images-amd64.tar.gz
```

```shell
curl -L -o install_k3s.sh https://get.k3s.io
```

If you are running Red Hat Enterprise Linux with SELinux enabled, download the K3s policy package:

🔍 **SELinux policy package download**

Lookup the latest version of the K3s SELinux Policy package:

```shell
K3S_SELINUX_DOWNLOAD_URL=$(curl -s https://api.github.com/repos/k3s-io/k3s-selinux/releases/latest | jq -r '.assets[] | select( .name | endswith("el8.noarch.rpm") ) | .browser_download_url') && echo $K3S_SELINUX_DOWNLOAD_URL
```

> [!NOTE]
> You can view the versions available and find the download links on the K3s SELinux [releases page](https://github.com/k3s-io/k3s-selinux/releases).

Then download it:

```shell
curl -L -o k3s-selinux.el8.noarch.rpm $K3S_SELINUX_DOWNLOAD_URL
```

<a id="airgap_helm_download"></a>

#### 1.2 Download Helm

Use the [compatibility matrix](https://docs.gradle.com/develocity/2025.3/miscellaneous/compatibility/#kubernetes_and_helm) to identify the latest version of Helm supported by your version of Develocity.

Download the Helm binary:

```shell
curl -L -o helm-linux-amd64.tar.gz https://get.helm.sh/helm-v3.18.6-linux-amd64.tar.gz
```

> [!NOTE]
> You can see all available Helm releases on the Helm [releases page](https://github.com/helm/helm/releases).

<a id="1-3-download-the-installation-bundle"></a>

#### 1.3 Download the Installation Bundle

Save your Develocity license to the transfer directory as `develocity.license`.

Download and verify the airgap bundle:

```shell
curl -LOJd @develocity.license \
  https://registry.gradle.com/airgap/gradle-enterprise-standalone-2025.3.3-bundle.tar.gz
```

```shell
curl -LOJd @develocity.license \
  https://registry.gradle.com/airgap/gradle-enterprise-standalone-2025.3.3-bundle.tar.gz.sha256
```

```shell
sha256sum -c gradle-enterprise-standalone-2025.3.3-bundle.tar.gz.sha256
```

If the checksum verification fails, check the contents of the downloaded files for error messages.  
If the error message indicates that your license is invalid/expired/not airgap enabled, you will need to request an updated license file by contacting your customer success representative.

> [!TIP]
> Instead of running the above `curl` commands, you can download the airgap bundle by navigating to [https://registry.gradle.com/airgap](https://registry.gradle.com/airgap) in your browser and following the instructions on the page.

<a id="2-prepare-a-helm-values-file"></a>

### 2. Prepare a Helm Values File

Installation options for Develocity are depicted in a Helm values file.

Follow the instructions in the [Standalone Helm Chart Configuration Guide](https://docs.gradle.com/develocity/2025.3/reference/standalone-chart/) and return to this document with a complete `values.yaml` file.

Before transferring files to your host, make sure your Helm values file is updated in your transfer directory.

<a id="3-transfer-files"></a>

### 3. Transfer Files

Check that the transfer directory has the following files (additional files are fine):

*   `k3s-airgap-images-amd64.tar.gz`
    
*   `k3s`
    
*   `install_k3s.sh`
    
*   `k3s-selinux.el8.noarch.rpm` (only if you are running SELinux)
    
*   `helm-linux-amd64.tar.gz`
    
*   `develocity.license`
    
*   `values.yaml`
    
*   `gradle-enterprise-standalone-2025.3.3-bundle.tar.gz`
    
*   Optional: SSL certificates
    

Once you’ve verified that you have the required files, transfer them to the host where you are installing Develocity.

<a id="4-install-k3s"></a>

### 4. Install K3s

Follow these instructions on the host where you are installing Develocity with your transferred files present in the current directory.

If you are running Red Hat Enterprise Linux with SELinux enabled, first install the necessary policy packages:

🔍 **SELinux Policy installation**

1.  Install the `container-selinux` package. This is a package that can be found in Red Hat Enterprise Linux’s default repository. Install this package on the airgapped server just such as you would install any other package. If your organization has an internal mirror of the Red Hat package repositories, you can run:
    
    ```shell
    sudo yum install -y container-selinux
    ```
    
2.  Install the K3s SELinux Policy package you downloaded:
    
    ```shell
    sudo yum install -y k3s-selinux.el8.noarch.rpm
    ```
    

Then install and set up K3s:

1.  Install K3s and make it available to the current user:
    
    ```shell
    sudo mkdir -p /var/lib/rancher/k3s/agent/images/ && \
      sudo cp k3s-airgap-images-amd64.tar.gz /var/lib/rancher/k3s/agent/images/
    ```
    
    ```shell
    (cd /var/lib/rancher/k3s/agent/images/ && sudo gunzip -f k3s-airgap-images-amd64.tar.gz)
    ```
    
    ```shell
    sudo cp k3s /usr/local/bin && sudo chmod a+rx /usr/local/bin/k3s
    ```
    
    ```shell
    sudo chmod a+rx ./install_k3s.sh && INSTALL_K3S_SKIP_DOWNLOAD=true ./install_k3s.sh
    ```
    
    ```shell
    sudo chown $UID /etc/rancher/k3s/k3s.yaml && \
      mkdir -p "${HOME}/.kube" && \
      ln -sf /etc/rancher/k3s/k3s.yaml "${HOME}/.kube/config"
    ```
    
2.  Verify that you can interact with the K3s cluster:
    
    ```shell
    kubectl get namespace
    ```
    
    **Output:**
    
    ```
    NAME                STATUS   AGE
    default             Active   1h
    kube-system         Active   1h
    kube-public         Active   1h
    kube-node-lease     Active   1h
    ```
    

<a id="5-install-helm"></a>

### 5. Install Helm

Follow these instructions on the host where you are installing Develocity with your transferred files present in the current directory.

To install Helm:

```shell
tar -zxvf helm-linux-amd64.tar.gz && sudo mv linux-amd64/helm /usr/local/bin/helm
```

<a id="6-install-develocity"></a>

### 6. Install Develocity

Follow these instructions on the host where you are installing Develocity with your transferred files present in the current directory.

Install Develocity:

```shell
tar zxvf gradle-enterprise-standalone-2025.3.3-bundle.tar.gz
```

```shell
sudo k3s ctr images import gradle-enterprise-standalone-2025.3.3-images.tar (1)
```

1. This command imports the images into K3s.

```shell
helm install \
  --create-namespace --namespace develocity \(1)
  ge-standalone \(2)
  gradle-enterprise-standalone-2025.3.3.tgz \
  --values values.yaml \(3)
  --set-file global.license.file=./develocity.license (4)
```

1. This example uses develocity as the namespace, but it can be a custom name. If you use a custom name, update all other example commands accordingly.
2. This is the Helm release name. It is used by Helm to identify the Develocity installation.
3. The Helm values file with configuration values, including items such as the hostname.
4. The Develocity license file (if not already included in values file).

<a id="start_gradle"></a>

### 7. Start Develocity

You can see the status of Develocity starting up by examining its Pods.

```shell
kubectl get pods --namespace develocity
```

**Output:**

```
NAME                                              READY   STATUS              RESTARTS   AGE
gradle-enterprise-operator-76694c949d-md5dh       1/1     Running             0          39s
gradle-embedded-object-storage-d6586c984-f88qx    1/1     Running             0          39s
gradle-monitoring-5545d7d5d8-lpm9x                3/3     Running             0          39s
gradle-node-monitoring-7589798b74-7tpml           1/1     Running             0          39s
gradle-database-65d975cf8-dk7kw                   0/2     Init:0/2            0          39s
gradle-build-cache-node-57b9bdd46d-2txf5          0/1     Init:0/1            0          39s
gradle-proxy-774cfc5987-57t5q                     0/1     ContainerCreating   0          39s
gradle-metrics-cfcd8f7f7-zqds9                    0/1     Running             0          39s
gradle-test-distribution-broker-6fd84c6988-x6jvw  0/1     Init:0/1            0          39s
gradle-keycloak-555cc89b6f-rcgd5                  0/1     Pending             0          39s
gradle-enterprise-app-6c8cbb5949-hk7rq            0/1     Pending             0          39s
```

Eventually the Pods should all report as `Running`:

```shell
kubectl get pods --namespace develocity
```

**Output:**

```
NAME                                               READY   STATUS    RESTARTS   AGE
gradle-enterprise-operator-76694c949d-md5dh        1/1     Running   0          4m
gradle-embedded-object-storage-d6586c984-f88qx     1/1     Running   0          4m
gradle-monitoring-5545d7d5d8-lpm9x                 3/1     Running   0          4m
gradle-node-monitoring-7589798b74-7tpml            1/1     Running   0          4m
gradle-proxy-774cfc5987-57t5q                      1/1     Running   0          3m
gradle-database-65d975cf8-dk7kw                    2/2     Running   0          3m
gradle-enterprise-app-6c8cbb5949-hk7rq             1/1     Running   0          3m
gradle-metrics-cfcd8f7f7-zqds9                     2/2     Running   0          3m
gradle-test-distribution-broker-6fd84c6988-x6jvw   1/1     Running   0          3m
gradle-keycloak-555cc89b6f-rcgd5                   1/1     Running   0          3m
```

Once all Pods have a status of `Running` and the system is up and connected, you can interact with it by visiting its URL in a web browser (i.e. the hostname).

<a id="8-cleanup"></a>

### 8. Cleanup

It is recommended to remove the following files after installation:

*   `k3s-airgap-images-amd64.tar.gz`
    
*   `k3s`
    
*   `install_k3s.sh`
    
*   `k3s-selinux.el8.noarch.rpm`
    
*   `helm-linux-amd64.tar.gz`
    
*   `gradle-enterprise-standalone-2025.3.3-bundle.tar.gz`
    
*   `gradle-enterprise-standalone-2025.3.3.tgz`
    
*   `gradle-enterprise-standalone-2025.3.3-images.tar`
    

Once Develocity has been installed, files used during installation are not required at runtime and can be removed if desired. However, the following files may be useful to preserve, as they may aid in future upgrades or maintenance:

*   Helm values files
    
*   SSL certificates
    
*   Develocity license
    

> [!WARNING]
> Care should be applied when handling these files as they may be considered sensitive.

**Congratulations Develocity is installed and running.**

<a id="using_gradle_enterprise"></a>

## Post-Installation

Many features of Develocity, including access control, database backups, and Build Scan retention can be configured in Develocity, once it is running. Consult the [Develocity Administration](https://docs.gradle.com/develocity/2025.3/administration/admin-manual/) guide to learn more.

<a id="next_steps"></a>

## Next Steps

[Standalone Helm Chart Configuration Guide](https://docs.gradle.com/develocity/2025.3/reference/standalone-chart/) - Develocity Helm chart options.  
[Develocity Administration Manual](https://docs.gradle.com/develocity/2025.3/administration/admin-manual/) - Learn how to configure and administer Develocity.  
[DPE University](https://dpeuniversity.gradle.com/app/catalog?product=Develocity) - A free, self-paced training portal to get the most out of Develocity.  

* * *

If you have any questions or need any assistance contact the Develocity support team or your customer success representative.

<a id="uninstall"></a>

## Appendix A: Uninstalling Develocity

To uninstall Develocity, follow the [Uninstall Guide](https://docs.gradle.com/develocity/2025.3/upgrade-uninstall/uninstall/).