Private preview Help shape simpler Kubernetes image updates. Request access

Day-2 image updates for Kubernetes teams

Keep Kubernetes apps updated.
Without the rollout scramble.

When a patched base image arrives or a new application image is ready, getting it into Kubernetes should be straightforward. FreshLayer is designed to coordinate affected-app rebuilds when needed, approved image updates, and rollout tracking through the tools you already use.

  • Find updated images
  • Rebuild only when needed
  • Roll out through existing GitOps
A new image is available Patch or app update Tracked OCI image digest
FreshLayer Find. Update. Roll out. One coordinated day-2 workflow
Rebuild if needed Updated app image Existing CI, pinned inputs
Approve and deliver Verified digest GitOps-first release
Kubernetes Updated app running Rollout status per target
Fits your current operations stack
OCI registries Existing CI GitOps Kubernetes

Your day-2 update workflow

From patched image to updated Kubernetes workload.

One practical path for routine image maintenance, whether a base-image change calls for a rebuild or an updated application image is already available.

  1. 1

    Find the image update

    Track a base or application image change and resolve its exact digest instead of relying on a moving tag.

  2. 2

    Prepare an updated app image

    For a base-image patch, rebuild opted-in apps through existing CI with pinned inputs. Already-built app images can skip rebuilding.

  3. 3

    Verify and approve

    Check the published image, select the digest to release, and apply each environment's release policies and approvals.

  4. 4

    Roll out and confirm

    Update desired state through the authorized GitOps path, then track whether Kubernetes actually runs the intended image.

The day-2 problem

The patch is available. Why is updating the application still so much work?

A patched base image does not automatically update the applications built from it. And a new application image in a registry does not automatically update a Kubernetes workload. FreshLayer is designed to connect these missing steps so operators can move from an available fix to an approved, observable rollout with less manual coordination.

Spot the update

Track base and application image changes, resolve exact digests, and identify the application update path.

Rebuild where needed

Coordinate opted-in rebuilds with pinned dependencies and chosen source revisions. An externally built app image can enter directly.

Simplify the rollout

Select a verified replacement and deliver the authorized image change through GitOps without manually editing every workload.

Know what's running

See intended and observed image state for each target, including updates waiting on approval, blocked, or not yet healthy.

Less day-2 glue work

Update applications without replacing your stack.

FreshLayer is designed to coordinate the gap between image publication and Kubernetes rollout. Your registries, CI, GitOps tools, and Kubernetes controllers continue to do their jobs.

Talk to us about your workflow
Registry

Keep existing OCI registries

Use the patched base and updated app images you already publish. No replacement registry or image proxy is required.

CI

Rebuild through your normal CI

Pass pinned image dependencies and a selected source revision to your existing build system when a rebuild is necessary.

GitOps

Keep Git as the rollout authority

For Git-managed workloads, update the requested image through Git. Argo CD or Flux remains responsible for applying desired state.

K8s

See the real Kubernetes result

Native controllers perform rollouts. FreshLayer aims to show whether each workload reached the intended digest and became healthy.

Safe by design

Routine updates without surprise deployments.

Making patches easier to roll out does not mean releasing every registry update to production. FreshLayer separates an available image, an approved target update, and proof of what is actually running.

Exact image identities

Use immutable, digest-qualified images for build inputs and deployment choices.

Approval per environment

Finding a patch does not grant permission to ship it to a protected target.

No competing delivery writers

GitOps retains control of Git-managed image fields instead of being bypassed by direct cluster patches.

Operator controls for day 2

Planned controls include pausing updates, retrying blocked work, and authorizing scoped rollback while keeping rollout status visible.

Planned private preview

Start with the day-2 update loop.

FreshLayer is in development. These are priority workflows for preview, not a claim that the product or every integration is already generally available.

Preview focus

Find new base and app images

Observe changing image references, retain immutable digests, and show pending updates.

Preview focus

Rebuild affected applications

Use declared image dependencies and pinned inputs to coordinate opted-in CI rebuilds.

Preview focus

Choose an approved replacement

Verify the candidate artifact, then select and authorize its promotion by environment.

Preview focus

Roll out through GitOps

Prepare authorized image changes in Git and track whether Kubernetes reaches the requested state.

Later phase

Optional direct Kubernetes delivery

Support non-GitOps targets with scoped control, without conflicting owners for image fields.

Later phase

Broader fleet and provider coverage

Expand integrations and cross-cluster visibility as real-world update workflows are validated.

FAQ

Practical questions about day-2 image updates.

Does FreshLayer create patches or scan for vulnerabilities?

No. Patched images come from upstream image providers or your build processes. FreshLayer is designed to coordinate adoption of those images, not replace scanners or author security fixes.

Does every image update require an application rebuild?

No. An updated base image may require an opted-in application rebuild using existing CI. An app image already published by your CI can enter the same verified release workflow directly.

Does it replace CI, registries, or GitOps?

No. Your existing registry serves images, CI builds them, GitOps owns Git-managed desired state, and Kubernetes performs the rollout. FreshLayer is intended to connect those steps.

Will a patched image deploy to production automatically?

Not without the required target authorization. Detecting an image update is not permission to deploy it. Protected environments can require approvals, and GitOps-managed workloads change through Git.

How will we know whether the update actually landed?

The planned workflow keeps selected, desired, and running image identities separate for each target. A successful CI job or Git commit alone is not treated as a successful Kubernetes rollout.

What if an update gets stuck or needs to be reversed?

The planned day-2 controls let operators inspect why work is blocked, pause or retry an operation, and authorize a target-specific rollback to a retained image. A rollback is a new controlled release, not a silent global reset.

Is FreshLayer available today?

Not generally. FreshLayer is being prepared for focused private previews. Request early access to tell us about your Kubernetes image maintenance workflow.

Early access

Make the next Kubernetes image update routine.

Tell us where adopting patched images and rolling out updated apps slows your team down. Help shape a simpler day-2 workflow.

Request early access Designed for your existing delivery stack.