Skip to main content

Components

Components are the building blocks of a Kumoto project. Add one from the project canvas, then configure it for the responsibility it has in your application. Each component has settings appropriate to its type, along with variables and a deployment target.

Choose the smallest set of components that represents your application clearly:

  • An application runs your web service, worker, or frontend.
  • A database stores durable application data.
  • A cache holds short-lived or frequently accessed data.
  • A cron job runs scheduled work.

The component catalog lists the currently available component types.

Add an application​

Use a runtime-based application when Kumoto can build and run your source directly, a Static Application for built frontend files, or a Docker Application when your service is packaged as a container image.

For source-backed applications, first connect your source-control provider, then select a repository and the branch, tag, or commit to deploy. Configure the commands and paths your application needs in its settings. Keeping these settings with the component makes the deployed revision easier to reproduce and review.

Before deploying, choose the server that will run the component. You can change the server in a later draft when your infrastructure needs to evolve.

Add backing services​

Add a database or cache as its own component instead of treating it as part of an application. Then connect it to the application that uses it. This keeps the relationship visible and lets you manage lifecycle changes separately from application code changes.

For example, a typical project could connect a Laravel application to PostgreSQL and Valkey. The application can import compatible connection values from those linked components rather than duplicating them manually.

Configure variables​

Variables hold configuration that your application reads at runtime. Kumoto presents them in three groups:

  • Built-in variables are supplied by Kumoto for the component.
  • Custom variables are values you provide, such as application settings, feature flags, and secrets.
  • Imported variables come from a linked component, such as database connection details.

Use variables for values that differ between deployments or should not live in source control. Add secrets directly in Kumoto and limit access to people who need to manage them. When updating a secret, make the change in a draft and deploy it with the application change that requires it.

Configure domains​

HTTP-capable applications can receive traffic on one or more domains. Add domains from the component's Domains tab, then review and deploy the draft to apply the change.

Before you deploy, make sure the domain is intended for that application and that its DNS can be directed to the server. Keep domain changes with the relevant application change where possible; this makes a rollout easier to audit and, if necessary, reverse.

Scheduled work​

Use a Cron Job for commands that run on a schedule, such as cleanup tasks, report generation, or queue maintenance. Give scheduled work its own component when it has an independent schedule or deployment lifecycle. It can use the same project variables and connected services as the rest of your application, while remaining easy to identify on the canvas.

Review before deployment​

Component changes stay in the project draft until you deploy them. Before selecting Review and deploy, confirm that:

  • Each new component has the intended server.
  • The selected repository revision and application settings are correct.
  • Variables and imported values point to the expected services.
  • Domains and component connections match the application design.

Kumoto checks the component configuration when it prepares a deployment and highlights issues that need your attention.