Migrating to IaCConsole

A practical path off CDKTF and constrained HCP Terraform plans, without rewriting your infrastructure or building internal tooling.

If you are here, you are probably facing one of these situations:

  • CDKTF was archived on December 10, 2025 and you need a maintained home for your infrastructure code.
  • Your HCP Terraform plan has limits on managed resources or concurrent runs, and your team is hitting them.
  • You want a repeatable workflow with AI assistance, reusable code, and no vendor lock-in.
  • Your team spends too much time on internal IaC tooling: pipelines, config management, state backends, and audit logs.

IaCConsole is built for small teams that own their infrastructure and want a repeatable workflow without building internal tooling or hiring a dedicated platform team. This guide covers the CDKTF path in detail, then the HCP Terraform path.


What changed

CDKTF was archived, not deleted

HashiCorp archived the Cloud Development Kit for Terraform (CDKTF) on December 10, 2025. The code remains available on GitHub under the MPL license and you can keep using it, but the repository is read-only. There are no fixes, security patches, or provider compatibility updates.

That matters because CDKTF sat on top of Terraform and generated provider bindings. As Terraform, OpenTofu, and providers move forward, an unmaintained layer will drift further from the versions you need.

Terraform was always underneath

CDKTF synthesized Terraform configuration and ran it through Terraform. Your resources and your state already belong to the Terraform ecosystem. The migration is mostly converting synthesized configuration into HCL your team can maintain, and reconciling resource addresses where generated names differ from old construct paths.

HashiCorp documented the exit

The sunset notice points to cdktf synth --hcl, which generates readable HCL from your project instead of the JSON Terraform normally receives. That output is the starting point for a standard workflow, not a finished one. Review naming, module boundaries, and variables before you apply it.

Source: HashiCorp’s CDKTF sunset notice.

HCP Terraform plan limits

HCP Terraform still offers a free plan, but it caps managed resources and concurrent remote runs. For a team running several environments or planning changes in parallel, those limits become the real constraint. Check the current plan comparison before you plan around them.

The important part is not a deadline. It is that the limits are documented, predictable, and worth planning for.


The CDKTF migration path

HashiCorp’s own advice was to migrate to HCL. This is the sequence that works, whether you finish in a weekend or move one stack at a time.

1. Generate HCL from your project

Run the supported conversion while your toolchain still works. Keep the output in version control so every later change is reviewable.

cdktf synth --hcl

# Review what was generated before doing anything else
ls cdktf.out/stacks/

The generated files usually land in cdktf.out/stacks/<your-stack>/. Treat them as a starting point: check resource names, module boundaries, and hardcoded values.

2. Point Terraform at your existing state

Terraform state is not CDKTF-specific. Keep the same backend you used with CDKTF, or copy the state to the backend you want going forward. Then initialize and plan.

terraform init
terraform plan

# If addresses differ, reconcile them instead of recreating:
# terraform state mv <old-address> <new-address>

An empty plan means the conversion is faithful. Anything else is a decision you should make deliberately.

3. Organize the output into units

Generated HCL is flat. Group it by purpose, extract environment-specific values into variables, and remove drift you no longer want to manage.

units/
  acme/
    network/      # VPC, subnets, routing
    data/         # RDS, S3, backups
    app/          # compute, queues, CDN

inventory/
  acme/
    dev.json
    prod.json

In IaCConsole, a Unit is a deployable piece of infrastructure with a clear purpose. A Dimension is environment-specific configuration data. Splitting the two is what removes per-environment copy-paste.

4. Extract configuration into dimensions

Look for hardcoded values in your HCL (instance types, CIDR blocks, region names) and move them to dimension files.

Before (CDKTF-synthesized HCL):

resource "aws_instance" "app" {
  ami           = "ami-12345678"
  instance_type = "t3.large"  # Hardcoded

  tags = {
    Environment = "prod"      # Hardcoded
  }
}

After (IaCConsole Unit):

resource "aws_instance" "app" {
  ami           = "ami-12345678"
  instance_type = var.iacconsole_env_data.instance_type

  tags = {
    Environment = var.iacconsole_env_name
  }
}

Configuration (inventory/acme/env/prod.json):

{
  "instance_type": "t3.large",
  "backup_enabled": true
}

5. Create a unit manifest

Each unit needs a unit_manifest.json describing its required dimensions.

{
  "required_dimensions": ["org", "env", "datacenter"]
}

6. Deploy with the IaCConsole CLI

Download the latest binary for your platform (Linux or macOS, x86-64 or arm64) from GitHub Releases.

# Start the agent locally
iacconsole-cli agent

# Or run a plan directly from the CLI
iacconsole-cli exec plan --org acme --env prod --dc us-east-1 --unit network

The CLI injects the backend configuration at init time and builds a unique state path from your org, dimensions, and unit name. No manual key management.

7. Review, then apply

Treat the first plan as a migration test.

terraform plan -out=migration.tfplan

# Apply only after the diff matches your intent
terraform apply migration.tfplan

Start with one stack that has a low blast radius. Confirm that terraform plan is empty against existing state. That single result tells you more than any migration plan document.


Before and after

A small stack, converted. The resources are the same; the second version is the one your team can read, review, and hand to any Terraform tool.

CDKTF (TypeScript):

class AssetsStack extends TerraformStack {
  constructor(scope: Construct, id: string) {
    super(scope, id);
    new AwsProvider(this, 'aws', {
      region: 'eu-central-1',
    });

    const bucket = new S3Bucket(this, 'assets', {
      bucket: 'acme-assets-prod',
    });

    new S3BucketVersioningA(this, 'assets-versioning', {
      bucket: bucket.id,
      versioningConfiguration: { status: 'Enabled' },
    });
  }
}

Standard HCL:

provider "aws" {
  region = "eu-central-1"
}

resource "aws_s3_bucket" "assets" {
  bucket = "acme-assets-prod"
}

resource "aws_s3_bucket_versioning" "assets" {
  bucket = aws_s3_bucket.assets.id

  versioning_configuration {
    status = "Enabled"
  }
}

Where IaCConsole fits

IaCConsole does not rewrite your CDKTF code for you. The conversion is HashiCorp’s cdktf synth --hcl. Our job starts after it.

  • AI agents review the generated HCL. They explain what each resource does and propose module boundaries before you split a flat stack by hand.
  • DevSecOps and FinOps review the plan for security and cost issues while it is still a diff, not after it is applied.
  • Secure Agent Mode runs Terraform in your environment, so the cloud credentials you already have do not need to move.
  • The output stays standard HCL. Export it and run it anywhere, with or without IaCConsole.

If your CDKTF project is tightly integrated with AWS CDK, HashiCorp suggested evaluating AWS CDK directly. If it is plain CDKTF, standard HCL is the lower-risk path.


Migrating from HCP Terraform

If you are moving because of managed-resource or concurrency limits, the work is smaller than a CDKTF migration because your code is already HCL.

1. Export your code and state

Clone your Terraform repositories. You likely already have organized code, which is a head start.

# Export state from HCP Terraform
terraform state pull > terraform.tfstate

2. Restructure as units

If your code is already in modules, converting to units is mostly a directory change.

HCP Terraform structure:

environments/
  dev/
    main.tf          # Calls modules with vars
    terraform.tfvars
  prod/
    main.tf          # Duplicate calls
    terraform.tfvars

IaCConsole structure:

units/
  acme/
    infrastructure/
      main.tf
      unit_manifest.json

inventory/
  acme/
    env/
      dev.json
      prod.json
    datacenter/
      us-east-1.json
      eu-west-1.json

3. Import existing state

iacconsole-cli state import \
  --org acme \
  --env prod \
  --dc us-east-1 \
  --unit infrastructure \
  --file terraform.tfstate

4. Update the backend configuration

Remove HCP Terraform backend blocks and let the CLI manage state. For example, with S3:

terraform {
  backend "s3" {}
}

The CLI supplies -backend-config flags at init time. See the Terraform state guide for backend details.

5. Run plans in parallel

Run plans for multiple environments at once instead of queueing behind a single remote run.

iacconsole-cli exec plan --org acme --env dev --unit network &
iacconsole-cli exec plan --org acme --env staging --unit network &
iacconsole-cli exec plan --org acme --env prod --unit network &

Migration checklist

Before you start

  • [ ] Audit your current infrastructure: resource count, dependencies, state locations.
  • [ ] Identify logical units: network, data, applications, and so on.
  • [ ] Create an account at app.iacconsole.com.
  • [ ] Install the CLI from GitHub Releases.
  • [ ] Convert one stack with cdktf synth --hcl and review the output.

During migration

  • [ ] Create the organization structure under units/.
  • [ ] Define the dimension hierarchy: org, env, datacenter.
  • [ ] Organize HCL into units.
  • [ ] Move environment-specific values into dimension JSON files.
  • [ ] Add a unit_manifest.json to each unit.
  • [ ] Test locally with iacconsole-cli exec plan.
  • [ ] Import existing state, then confirm the first plan is empty.

After migration

  • [ ] Verify state consistency and run drift detection.
  • [ ] Update CI/CD pipelines to use the CLI or API.
  • [ ] Train the team on Units and Dimensions.
  • [ ] Archive old HCP Terraform workspaces or CDKTF projects.
  • [ ] Turn on plan review for production changes.

Common questions

Is CDKTF still usable after the archive?

Yes. The code remains available on GitHub under the MPL license and you can keep using it. But the repository is read-only: HashiCorp no longer ships fixes, security patches, or compatibility updates for new Terraform and provider versions. That is why most teams plan a move now rather than later.

What does cdktf synth --hcl actually produce?

It generates readable HCL configuration from your CDKTF project instead of the JSON Terraform normally receives. HashiCorp documented it as the migration path before archiving the project. The output is a starting point: review naming, module boundaries, and variables before you apply it.

Do I have to rewrite my infrastructure from scratch?

No. CDKTF synthesized configuration and ran it through Terraform, so your resources and state are already Terraform resources and state. The work is converting the synthesized configuration into maintainable HCL and reconciling resource addresses where generated names differ from your old construct paths.

Will my existing state still work?

Terraform state is not CDKTF-specific. Point the generated configuration at the same backend, run terraform init, and compare with terraform plan. If the plan wants to replace resources because their state addresses changed, reconcile with terraform state mv before applying anything.

Does IaCConsole convert my CDKTF app automatically?

No. The supported conversion is HashiCorp’s cdktf synth --hcl. We help with the part after that: reviewing the generated HCL, organizing it into units, and running plans with security and cost review in your own cloud account.

How long does a CDKTF migration take?

It depends on how many stacks and resources you run. Start with one stack, confirm that terraform plan is empty against existing state, and move the rest stack by stack. Most of the effort is review and organization, not rewriting resources.

Can I import my existing Terraform state?

Yes. The CLI supports importing existing Terraform state files into your IaCConsole project. See Terraform state.


Getting help

Documentation

Community and support

For larger migrations, we can review your current setup, pair on converting one CDKTF stack, or run a migration workshop for your team.


Next step

Convert one stack with cdktf synth --hcl, confirm terraform plan is empty against your existing state, then decide how to organize it. Start with the quick start guide.

CDKTF is a project of HashiCorp, an IBM company. IaCConsole is not affiliated with or endorsed by HashiCorp.

Frequently asked questions

Is CDKTF still usable after the archive?

Yes, the code remains available on GitHub under the MPL license, but the repository is read-only and no longer receives fixes, security patches, or provider compatibility updates.

What does cdktf synth --hcl produce?

It generates readable HCL from your CDKTF project instead of the JSON Terraform normally receives. Review naming, module boundaries, and variables before applying it.

Do I have to rewrite my infrastructure from scratch?

No. CDKTF synthesized configuration and ran it through Terraform, so your resources and state are already Terraform resources and state. The work is converting the output into maintainable HCL.

Will my existing state still work?

Yes. Point the generated configuration at the same backend, run terraform init and terraform plan, and use terraform state mv to reconcile any changed resource addresses before applying.

Can I import my existing Terraform state?

Yes. The CLI supports importing existing Terraform state files into your IaCConsole project.