This release focuses on serverless CI/CD powered by Laboratory @Builds and @Previews, bringing isolated, scalable execution environments to your pipelines and preview deployments.

What's New​

Laboratory @Builds: Serverless CI/CD Cells​

CABLO Laboratory @Builds is a CI/CD solution built on CABLO Cells — isolated execution environments with guaranteed resources and predictable performance.

Key capabilities:

• Isolated execution: Every job runs in a fresh @build cell
• Horizontal scaling: Cells scale automatically based on demand
• Resource guarantees: Power tiers (@bit, @pro, @mega) ensure predictable performance
• Native integrations: Buck Mirrors, Buck Registry Space, CABLO API, and Hub — all integrated out of the box

How it works:

1. Push code to your repository
2. CABLO Hub detects changes and triggers a pipeline
3. Jobs are routed to cells based on tags
4. Each job runs in an isolated cell
5. View logs, artifacts, and reports in the dashboard

Example .cablo.yml configuration:

stages:
  - build
  - test

build:backend:
  stage: build
  tags: ["@auto", "@build", "@pro"]
  script:
    - npm install
    - npm run build
  artifacts:
    paths:
      - dist/

test:unit:
  stage: test
  tags: ["@auto", "@build", "@bit"]
  script:
    - npm test

Learn more about @Builds →

Laboratory @Previews: Ephemeral Preview Environments​

@preview cells provide ephemeral preview environments for rapid application testing and development.

Available APIs:

• Reserve Preview API: Reserve a preview cell
• Start Preview API: Start a preview environment
• Refuel Preview API: Extend preview lifetime

Perfect for testing branches, PRs, and feature work in isolated environments.

Explore @Previews API →

Features & Improvements​

• Resilient Internal CABLO — Enhanced stability and fault tolerance
• CABLO Buck MVP — Initial release of Buck integration
• CABLO Hub MVP — Initial release of Hub integration
• Resource Power Improvement — Optimized resource allocation
• Fixed SSL Certificate Issues — Improved security and routing

Introducing the CABLO Blog​

This is our first platform update post on the new CABLO Blog. Expect regular updates on features, architecture deep-dives, and community highlights.

Get Started​

• Create Your First Pipeline
• Understand @build Cells
• Explore Cell Power Tiers
• CABLO Architecture

Questions or feedback? Reach out via CABLO Line at Telegram or Bale.

They fail because their tools are fragmented.

A typical development stack today looks like this:

• One service for Git collaboration
• Another for CI/CD
• A separate container registry
• External package repositories
• Manually configured preview environments
• VPNs and proxies holding everything together

Each tool works.
But the system as a whole does not.

And that’s where instability begins.

Stability Does Not Start with CI/CD​

Many teams try to fix release instability by improving pipelines.

They optimize runners.
They parallelize jobs.
They rewrite YAML files.

But release stability does not begin in the pipeline.

It begins at the moment a team collaborates on code.

Every commit, every merge request, every dependency pulled from an external source becomes part of a chain that eventually leads to production.

If any layer in that chain is unstable, the release will be unpredictable.

The Hidden Cost of Fragmentation​

When infrastructure components are separated:

• Builds fail because external dependencies are temporarily unavailable
• Pipelines slow down due to network instability
• Preview environments require manual setup
• Registry authentication breaks across services
• Engineers spend time debugging infrastructure instead of building product

Over time, this creates something more damaging than slow releases:

It erodes trust.

When teams don’t trust their pipelines, they deploy less frequently.
When they deploy less frequently, feedback slows down.
When feedback slows down, product velocity suffers.

Fragmentation quietly reduces momentum.

The Case for an Integrated Development Infrastructure​

Modern teams do not just need tools.

They need an integrated infrastructure layer that powers the entire development lifecycle:

From Git → to CI/CD → to Preview → to Release.

An integrated system ensures:

• Code collaboration naturally triggers pipelines
• Pipelines produce artifacts stored in the same trusted registry
• Dependencies are fetched from stable mirror repositories
• Preview environments are automatically provisioned
• The entire workflow operates without external fragility

When all layers are aligned, something important happens:

Development becomes predictable.

And predictability is the foundation of resilience.

Introducing CABLO​

CABLO is designed as an integrated development infrastructure subscription for software teams.

It provides:

• A full Git Collaboration environment
• Serverless CI/CD compute (no runner management required)
• Automatic Alpha/Beta Preview Deployments
• A dedicated Container Registry
• A stable VIP Mirror Repository for dependencies

All within a single, unified environment.

No DNS configuration.
No proxy setup.
No reliance on external infrastructure.

From the moment code is committed to the moment a version is released, the workflow remains consistent and controlled.

Resilience Is a System Property​

Resilience is not a feature you toggle on.

It is the result of architectural decisions.

When collaboration, build, artifact storage, and deployment exist as isolated islands, instability is inevitable.

When they operate as one coordinated system, resilience becomes natural.

That is the principle behind CABLO.

What This Blog Is About​

In this blog, we will explore:

• Why builds fail even when code hasn’t changed
• How preview environments reduce release risk
• Why dependency mirrors matter more than most teams think
• What makes CI/CD truly reliable
• How integrated infrastructure reduces cognitive load

If you are building software seriously, infrastructure is not background noise.

It is part of your product velocity.

Welcome to CABLO.