Infrastructure as Code

Click to provision.Terraform written, reviewed and kept in sync.

Codeface gives every engineer a visual control plane for cloud infrastructure — and gives your platform team clean, reviewable code in the repository they already trust.

100%
changes backed by IaC
0
Terraform expertise required
Git
native code & state
codeface.aezona.com
Designer
Provider
AWS · us-east-1
main.tf · generated
required_version = ">= 1.6.0"
required_providers {
aws = {
source = "hashicorp/aws"
version = "~> 5.84"
}
}
region = "us-east-1"
environment = "prod"
managed_by = "codeface"
resource "aws_db_instance" "app" {
identifier = "app"
PR #418 opened · infra/prod

What Codeface does

Design and change resources through the UI. Codeface generates clean Terraform, keeps it in Git, flags insecure configuration, and adopts unmanaged infrastructure without a recreate.

Visual resource designer

Compose VPCs, clusters, databases and networking across AWS, Azure and GCP on one canvas — with provider-aware validation before anything is written.

Terraform written for you

Every UI action produces formatted, idiomatic HCL using your module conventions. The code is the artefact — Codeface never holds state you cannot read.

Pull-request workflow

Changes land as a branch and a PR in your own repository, with a plan output attached. Existing review and CI gates apply unchanged.

See and change existing infra

The canvas shows the live estate — including click-ops nodes — so you can edit fields, adopt unmanaged resources into Terraform, and open a PR without starting from a blank graph.

Security flags on the canvas

Public storage, SSH from 0.0.0.0/0, and TrueSentinel findings light up in red. Fix from the inspector before a pull request can open.

Scoped access and approvals

Developers open PRs; operators review production. Apply runs in your Git CI after merge. Role gates decide who can publish which environments.

Curated module library

Publish your organisation's hardened modules as one-click templates so a compliant EKS cluster is the default path, not the difficult one.

How it works

01

Point Codeface at your repository

Connect the Git repository that holds your infrastructure code and the cloud accounts it manages. Codeface imports existing resources and reads your module structure.

02

Design or change a resource in the UI

Pick a provider, choose a template or start from a blank resource, and fill in the fields. Validation runs live against provider constraints and your own policy.

03

Review the generated code and plan

HCL updates as you place and edit resources. Open a pull request into your repo — Codeface writes environments/<env>/*.tf, not a proprietary graph.

04

Merge in Git

Merge the PR and your own pipeline applies it. Configure CI/CD and cloud authentication in the repository. Codeface never holds cloud keys or Terraform state.

Developer self-service

Engineers spin up compliant staging environments through the UI without learning HCL or waiting on a platform team ticket.

Adopting IaC on a live estate

Import resources that were created by hand, generate the code that describes them, and take ownership of it incrementally.

Governed production change

Every production change arrives as a reviewable pull request with a plan attached — approval gates enforced by the platform, not by convention.

Common questions

Does Codeface lock me into its own format?

No. Codeface writes standard Terraform into your repository. If you stop using it tomorrow, you keep working code and state exactly as they are.

What happens to resources someone changed in the console?

Drift detection catches them. Codeface shows the difference between the live resource and the committed code, and lets you either import the change or revert it.

Can it manage all three clouds at once?

Yes — AWS, Azure and GCP resources can live side by side in the same workspace, with per-provider credentials and per-environment access rules.

See Codeface against your own cloud.

Open the live workspace. A demo estate is already connected — design a resource, watch Terraform appear, and reconcile drift without a canned video.

Launch the workspace