Kingdom

Kingdom turns any Go repository into production-ready, validated deployment infrastructure.

Comment

Inspiration

Deploying an application often requires creating and maintaining many DevOps files: Dockerfiles, CI pipelines, Kubernetes manifests, Terraform, secrets, and documentation. These files are easy to generate incorrectly when the infrastructure is not based on a real understanding of the application.

We built Kingdom to make deployment preparation more intelligent, consistent, and transparent.

What it does

Kingdom analyzes a Go repository and detects:

Category Description
Go version Detected from repository configuration
Framework Identifies the framework in use
Application entry point Locates the main entry point of the app
Ports Detects ports used by the application
Routes Identifies application routes
Health endpoints Detects health check endpoints
Environment variables Identifies environment variables used
Tests Detects test files/suites
Makefiles Detects presence of Makefiles
Database and cache signals Identifies database and cache usage
Existing Docker configuration Detects existing Docker setup

It then generates:

Item
Dockerfile
Docker Compose
GitLab CI
Jenkinsfile
Kubernetes manifests
Terraform configuration
Deployment documentation
Analysis and validation reports

Kingdom also provides a visual web interface with artifact tabs, documentation, progress tracking, explanations, regeneration actions, deployment command copying, and ZIP downloads.

How we built it

Kingdom was built with a Python CLI and a lightweight HTML, CSS, and JavaScript web interface.

The analysis phase is deterministic and uses repository files such as go.mod, Go source files, Makefiles, and environment examples. The generation layer uses the analysis result to produce consistent infrastructure templates.

The system runs local validation commands when available, including:

  • go test
  • go build
  • Docker build
  • Docker Compose validation
  • Terraform formatting
  • Kubernetes validation

We also created a standalone Go demo project with API routes, health checks, configuration management, graceful shutdown, tests, and a Vercel-compatible Go Function entry point.

Challenges we ran into

The biggest challenge was making generated artifacts internally consistent. Ports, environment variables, container settings, Kubernetes services, and documentation all need to agree.

We also discovered that valid-looking configuration can still fail in real tools. During testing, we fixed:

  • Malformed YAML newline generation
  • Invalid Terraform nested blocks
  • Incorrect Docker build contexts
  • Go VCS build metadata issues
  • Kubernetes validation behavior when no cluster is available

Another challenge was supporting different deployment models. A long-running Go server used for Docker or Kubernetes is different from a serverless Go Function deployed to Vercel.

Accomplishments that we're proud of

  • Built a working end-to-end DevOps bootstrap workflow
  • Created deterministic Go repository analysis
  • Generated multiple deployment artifact types
  • Added validation and clear pass/fail/skip reporting
  • Built a polished, animated web interface
  • Added artifact documentation and progress tracking
  • Added dependency-free ZIP downloads
  • Created a realistic standalone Go demo project
  • Made the demo project deployable to Vercel
  • Used real validation failures to improve the generator instead of hiding them

What we learned

We learned that AI-generated infrastructure needs strong deterministic foundations. AI is useful for reasoning, synthesis, explanations, and recommendations, but basic repository facts should be discovered programmatically.

We also learned that validation is not an optional final step. It is part of the generation process. A configuration file is only useful if the target tool can parse and execute it.

Finally, we learned that developer trust depends on clear communication. Kingdom must explain what it

Built With

Share this project:

Updates