InfraKit: Infrastructure as Code, Finally Done Right

The Problem

Infrastructure-as-code was supposed to make cloud infrastructure manageable. Instead, it buried teams under YAML, HCL, and JSON — configuration formats pretending to be programming languages.

What we have today:

• Terraform / HCL

  • Custom DSL with a weak type system and limited composability
  • No real standard library, awkward abstractions, and brittle modules
  • Debugging is painful: a missing quote in a 500-line .tf file yields a cryptic error on the wrong line

• AWS CloudFormation

  • Thousands of lines of YAML/JSON for what should be a few function calls
  • No real loops or conditionals (unless you enjoy Fn::If and friends)
  • Errors show up at deploy time, often 10–20 minutes after you submit a stack

• Pulumi

  • Closer to what developers want (real languages), but
  • Proprietary state management introduces lock-in and operational overhead

• AWS CDK

  • TypeScript wrapper over CloudFormation, but
  • Inherits CloudFormation’s slow deployment model and AWS-only bias
  • Feedback loops are still slow; multi-cloud is an afterthought

Root cause: Infrastructure is a programming problem being solved with configuration languages.

You need:

• Loops and conditionals
• Types and compile-time safety
• Abstraction and composition
• Testing and refactoring
• IDE support and fast feedback

These are solved problems in real languages. Yet the same engineers writing beautiful, type-safe TypeScript apps are still wrestling with untyped YAML that only fails at deploy time.

The Solution: InfraKit

InfraKit lets you define cloud infrastructure in TypeScript — with full type checking, IDE autocomplete, real programming constructs, and deployment to AWS, GCP, and Azure from a single codebase.

No YAML. No HCL. No custom DSL.

How It Works

1. Write Infrastructure as TypeScript

Define resources using typed, composable APIs:

const db = new InfraKit.Postgres("db", {
  engine: "aurora-postgresql",
  version: "15",
  instanceSize: "db.serverless",
  storageGb: 64,
});

const api = new InfraKit.Lambda("api", {
  runtime: "nodejs20",
  handler: "src/api/index.handler",
  memory: 512,
  timeout: 30,
  environment: { DATABASE_URL: db.connectionString },
});

const gateway = new InfraKit.ApiGateway("gateway", {
  routes: [
    { path: "/api/*", method: "ANY", target: api },
  ],
});

It’s just TypeScript. Use functions, classes, generics, and the entire NPM ecosystem.

2. Get Instant Feedback

TypeScript catches infrastructure errors before deployment:

• Mistyped property name? Your IDE underlines it.
• Wrong type (string vs number)? Compile-time error.
• Reference a resource that doesn’t exist? Type error.

You get fast, local feedback instead of 15-minute deploy failures.

3. Compose and Abstract

Build reusable infrastructure primitives using normal TypeScript patterns:

function createMicroservice(name: string, opts: { memory?: number }) {
  const fn = new InfraKit.Lambda(name, {
    runtime: "nodejs20",
    handler: `services/${name}.handler`,
    memory: opts.memory ?? 512,
  });

  const api = new InfraKit.ApiGateway(`${name}-api`, {
    routes: [{ path: `/${name}/*`, method: "ANY", target: fn }],
  });

  return { fn, api };
}

Codify your organization’s best practices once, then reuse them everywhere.

4. Deploy with Confidence

• Typed diff before every deployment: see exactly what will change.
• Automatic rollback on failure.
• State stored in your cloud (S3, GCS, Azure Blob) — no proprietary state service.

InfraKit optimizes deployment plans, parallelizes resource creation, and avoids the slow plan/apply two-step.

Key Features

• Multi-cloud from day one

  • Unified TypeScript API for AWS, GCP, and Azure
  • Deploy identical stacks across providers or mix providers in a single project

• 100% type coverage

  • Every resource, property, and output is fully typed
  • Types auto-generated from cloud provider API schemas, always up to date

• Testable infrastructure

  • Use Jest or Vitest to unit test your infra:
    • Assert Lambda memory, timeouts, and permissions
    • Validate VPC CIDR blocks and subnet layouts
    • Ensure S3 buckets have encryption, versioning, and lifecycle rules

• Import existing resources

  • infrakit import reads your existing cloud resources
  • Generates typed InfraKit code so you can migrate incrementally from Terraform, CDK, or click-ops

• Policy as code

  • Define compliance rules in TypeScript:
    • “Every S3 bucket must have encryption enabled.”
    • “No public security group rules.”
    • “All Lambda functions must have X-Ray tracing.”
  • Run policies at compile time and in CI to block non-compliant changes before they hit production

• Preview environments

  • infrakit preview spins up a full copy of your stack per PR
  • Tear it down automatically on merge
  • Built-in, not bolted on

• Secrets management

  • Encrypted secrets with per-environment resolution
  • Centralized, auditable, and integrated with your cloud KMS
  • No more .env files in git or ad-hoc SSM parameters

• Drift detection

  • Continuously compares desired state (code) with actual cloud state
  • Alerts when someone changes resources manually in the console
  • Optionally auto-remediates drift

Why TypeScript (Not Python, Not Go)

• TypeScript has won the full-stack war

  • 78% of web developers use it
  • Infra engineers increasingly come from app dev backgrounds

• Unmatched IDE experience

  • VS Code + TypeScript delivers best-in-class autocomplete, refactoring, and error detection
  • Infrastructure code benefits from the same tooling as application code

• NPM ecosystem

  • Leverage millions of packages for validation, data manipulation, API clients, and more
  • No need to rebuild utilities that already exist

• One language for your stack

  • If your application is in TypeScript, your infrastructure should be too
  • One skill set, one hiring profile, one mental model

Traction

InfraKit is not a slideware idea — it’s already in the wild and growing fast:

• 20,000+ GitHub stars — among the fastest-growing infra tools in the ecosystem
• 1,500 companies using InfraKit in production, from startups to large enterprises
• $6M seed led by Greylock, with participation from Elad Gil and founders of HashiCorp and Vercel
• 85% reduction in infrastructure bugs for teams migrating from Terraform, driven by type checking and earlier feedback
• 40% faster average deployments vs equivalent Terraform workflows, thanks to parallel provisioning and a streamlined deploy model
• 3 major cloud providers fully supported with 2,000+ resource types

Business Model

InfraKit follows an open-core model designed to maximize adoption while monetizing team and enterprise needs.

• Open-source core (Free)

  • CLI, type system, and all cloud providers
  • State management using your own cloud storage
  • Basic policies and local workflows

• InfraKit Cloud — $99/team/month

  • Hosted state management
  • Drift detection dashboard
  • Centralized secrets management
  • Team collaboration features
  • Deployment history and audit logs

• Enterprise — $499/month

  • SSO and advanced RBAC
  • Custom policy packs and compliance reporting
  • Self-hosted option for regulated environments
  • Multi-account / multi-project governance
  • Dedicated support and SLAs

This structure keeps the core product accessible to individual developers and small teams, while providing clear value for organizations that need governance, security, and collaboration.

Market Opportunity

The infrastructure-as-code market is already $1.8B, growing 28% annually.

• Terraform holds 70%+ market share, but developer frustration with HCL is high
• Surveys consistently show IaC tooling as the #1 developer experience pain in DevOps

At the same time:

• There are 4.2M+ TypeScript developers, a number that continues to grow rapidly
• Infrastructure responsibility is shifting from centralized ops teams to product teams and full-stack developers

We’ve seen this movie before:

• XML and config-heavy frameworks gave way to JavaScript and TypeScript on the frontend
• The same shift is now happening in infrastructure: from YAML/HCL to real languages

InfraKit is positioned as the TypeScript-native IaC platform — the default choice for teams that already live in TypeScript and want infrastructure to feel like the rest of their codebase.

Team

InfraKit is built by people who created — and outgrew — the previous generation of tools:

• CEO — Former HashiCorp engineer who worked on Terraform’s core provider system and saw its limitations up close
• CTO — Former AWS CloudFormation team lead who helped build the service that processes 10M+ stack operations per day — and learned to hate its constraints
• Head of Developer Experience — Former Vercel DX lead who helped shape the philosophy behind Next.js and Vercel’s deployment platform

We’ve built the tools that defined the last decade of infrastructure. Now we’re building the tool we wished we had all along.

---

InfraKit: Infrastructure is a programming problem. It’s time it had a programming language.