Design layer overview

The design-layer engines, their inputs and data sources, and the parts not yet in the tree.

Purpose#

The design layer computes metro selection, topology, cost and estate sizing on top of the Fabric client. The engines read from the account. Only execute and reconcile on a deployment plan create resources.

Flow through the design layer. The DesignSpec is the shared input. Only execute and reconcile create resources.

Engines#

Engine	Entry point	Output	Status
DesignSpec	`DesignSpec.builder()`, `DesignSpecIO`	Versioned design document	New in 4.0
Metro Optimizer	`design.optimizeMetros()`	Set of metros for the sites, workloads and clouds	Rebuilt in 4.0
Deployment Wizard	`design.deploymentWizard(result)`	Resources to create, in order, with prices; drift against live state	Lifecycle New in 4.0
Estate analysis	`design.analyzeEstate()`	Findings on the existing estate	New in 4.0
Peering Intelligence	`design.peeringIntelligence()`	Presence of target networks at Equinix; peering lost with a metro
Cost and value	`design.savingsCalculator()`, `design.tcoComparison()`	Cost and savings of a design, with price sources
Cloud-to-cloud	`toCloud(...)` on the calculators, `cloudToCloudStrategy(...)` on the wizard	Cost of traffic between two clouds over Fabric and over a native provider link	Beta

Entry points#

Design gives access to the engines on top of a Fabric client. The engines read through the FabricGateway interface (metros, service profiles, Cloud Routers, connections, routing protocols, prices) and reuse the client's token and connection pool.

Java

import com.eqixiac.equinix.Design;
import com.eqixiac.equinix.Equinix;

try (Equinix eq = new Equinix(credentials)) {
    Design design = eq.design();           // or Design.over(fabric)
    design.optimizeMetros();               // builders; nothing is sent until the terminal call
    design.tcoComparison();
    design.analyzeEstate();
}

Fabric exposes the same builders directly: fabric.optimizeMetros(), fabric.deploymentWizard(result), fabric.peeringIntelligence(), fabric.savingsCalculator(), fabric.tcoComparison().

Shared rules#

An engine reports an item that it cannot price as unpriced, with a reason, and does not count it as zero. A latency that was neither measured nor computable is treated as unknown and is left out of scoring.
An engine adds amounts only within one currency and applies no exchange rate. It reports a result with mixed currencies as one subtotal per currency.
Each price in a result states its source: the live Equinix price search, a figure supplied by the caller, a provider's public price API, the bundled dated reference table, or an estimate.
A result records the fingerprint of the DesignSpec it was computed from and the time of the data it read, so that a run can be repeated and compared.

Data sources#

Data	Source	Notes
Metros, regions, connected-metro latency	Fabric Metros API	`avgLatency` is round-trip. Measured live on 2026-11-11: SV to DC 65.8 ms.
Which cloud is reachable in which metro	Fabric service profiles
Equinix prices	Fabric price search, live	Falls back to the reference card when a lookup cannot be answered
Cloud egress prices	Bundled reference table dated 2026-06, or the providers' public price APIs when enabled	List prices; a negotiated discount is not in them
Native cloud-to-cloud prices and region pairs	Bundled tables dated 2026-09-21	Copies of provider pages; they go stale
Network presence at exchanges and facilities	PeeringDB	Separate rate limit; optional API key
IBX coordinates	Internet Access	For IBX-to-IBX latency floors

Planned#

The plan lifecycle (diff, reconcile, rollback) and estate analysis entered the tree in the week of 2026-11-12. Their API may change before 4.0.0.