Integrating Existing Applications

This section guides you through integrating existing applications to run on the Ybor Platform. Whether you have a monolithic application, an existing containerized service, or something in between, these guides help you adopt platform capabilities incrementally—without requiring a full rewrite.

Why Integrate with the Platform?

Moving your applications to the Ybor Platform provides:

• Standardized CI/CD — Consistent build, test, and deploy workflows across all applications
• GitOps Deployments — Declarative infrastructure with ArgoCD for traceable, auditable releases
• Production-Ready Defaults — Automatic high availability, autoscaling, and security configurations
• Unified Observability — Centralized logging, metrics, and tracing across your entire portfolio

Integration Paths

Not every application needs full platform integration. Choose the approach that fits your situation:

Approach	When to Use	Effort
Full Integration	New greenfield projects or major rewrites	Higher upfront, lower ongoing
Incremental Adoption	Existing applications with ongoing development	Spread over time
Deployment Only	Stable applications that just need hosting	Minimal

Full Integration

Adopt all platform capabilities from the start: CI/CD, containerization, PlatformApplication manifests, and full observability. Best for new development or when you're already planning significant changes.

Incremental Adoption

Start with deployment, then progressively add observability, improve CI/CD, and modernize the codebase over time. This approach lets you realize benefits immediately while spreading the integration effort.

Deployment Only

If your application is stable and you primarily need managed hosting, you can deploy it with minimal changes. Add a Dockerfile, create a basic PlatformApplication manifest, and connect to ArgoCD. Observability and CI/CD improvements can come later.

Prerequisites

Before starting, ensure you have:

• GitHub repository access with Actions enabled
• Artifactory credentials (ARTIFACTORY_USERNAME, ARTIFACTORY_IDENTITY_TOKEN)
• Platform dispatch token (UPDATE_MANIFEST_TOKEN)
• Access to your organization's .platform repository
• ArgoCD access for your target environments

See Artifact Management for credential setup.

Integration Steps

The integration process follows four main phases, though not all are strictly required:

Phase	Requirement	Purpose
Assessing Readiness	Recommended	Evaluate your application and plan the integration
Builds	Recommended	Set up CI/CD and containerization
Deployments	Required	Create PlatformApplication manifests and connect to ArgoCD
Observability	Incremental	Add health checks, logging, metrics, and tracing

Start with the Minimum

You only need Deployments to get your application running on the platform. If your container image is already being built and published elsewhere, you can skip the Builds section and manually update the .platform folder. Automated CI/CD can be added later for a more streamlined workflow.

What's Different for Existing Applications?

If you've used platform generators for new projects, you'll notice that integrating existing applications requires more hands-on work:

• No scaffolding — You're adapting existing code rather than starting from templates
• Existing constraints — Your application may have dependencies or patterns that need accommodation
• Incremental approach — Changes happen within a running system

The guides in this section focus on these integration-specific challenges rather than repeating reference documentation. They'll point you to the appropriate reference sections when you need deeper detail.

In This Section

• Assessing Readiness — Evaluate your application and plan the integration path
• Builds — Set up CI/CD pipelines and containerization
• Deployments — Create PlatformApplication manifests and connect to ArgoCD
• Observability — Incrementally add health checks, logging, metrics, and tracing