Real Stories: Six Months to Production with AI Assistance

The Timeline

June 3, 2025: Initial commit. "Reclaiming our digital independence."

December 12, 2025: Production-ready platform with:

• Multi-cluster Kubernetes (management, test, production)
• Complete GitOps with Flux v2 and SOPS-encrypted secrets
• Centralized monitoring (Prometheus, Grafana, Loki, Mimir)
• 264 API tests with 100% endpoint coverage (58 endpoints)
• Modern E2E test suite with Playwright
• Production deployment on European infrastructure (Scaleway)

Six months. Small team. Running a company. Built on European values throughout.

Context That Matters

This isn't a case study from a huge organization with unlimited resources. This is proof that small teams can build European cloud independence fast with modern tooling.

Team size: 3-6 people (not dedicated full-time to this project)

Other constraints: Running Aknostic (our company), client work, other responsibilities. This project was built in parallel with running a business, not instead of it.

AI assistance: Claude as learning accelerator and pair programmer. This was explicitly an experiment: can small teams use AI tooling to build production systems faster?

Building on European values: Sovereignty by design, not retrofit. Every architectural decision considered: Where will data live? What laws apply? Which company benefits?

What Made This Possible

1. Kubernetes as Foundation

We didn't build abstractions from scratch. We built on Kubernetes—a proven platform with massive ecosystem support.

Managed Kubernetes (Scaleway Kapsule) meant we focused on applications, not control plane maintenance. Free control plane, pay only for worker nodes. This is the modern pattern: use managed services that reduce operational burden while maintaining portability.

2. GitOps from Day One

Everything in Git from the beginning:

• Infrastructure definitions (OpenTofu)
• Kubernetes manifests (deployments, services, Gateway API)
• Configuration (Helm values, Kustomize overlays)
• Secrets (SOPS-encrypted)
• Documentation (architecture decisions, runbooks)

This created natural guardrails: all changes reviewable in PRs, all deployments auditable in Git history, all configuration reproducible from repository.

3. AI as Learning Accelerator

Claude didn't write all our code. It helped us understand complex systems faster.

Examples:

• "Why isn't my Gateway attaching to this HTTPRoute?" → ReferenceGrants explained
• "How do I configure Flux to decrypt SOPS secrets?" → Complete config with explanation
• "Debug this cert-manager certificate chain issue" → Probable cause identified quickly

AI as pair programmer and documentation assistant. This made complex technologies (Kubernetes networking, GitOps reconciliation, mTLS) learnable in days instead of weeks.

4. Modern Testing Approach

We invested in testing from the start:

• 264 black-box API tests: Every endpoint covered, pure HTTP testing
• E2E tests with Playwright: User journey verification
• Independent test data: Tests create own data with unique identifiers

This isn't overhead—it's infrastructure for velocity. With comprehensive tests, we refactor confidently. Changes that break functionality get caught before deployment.

5. European Providers Ready for Production

In 2020, this might have been harder. European providers were catching up. Managed services were immature. Multi-AZ wasn't widely available.

By 2025, European providers offer production-ready platforms:

• Scaleway: Managed Kubernetes, object storage, DNS API, transactional email, container registry
• Multiple regions, each with 3+ availability zones
• Pricing competitive with hyperscalers
• Support responsive and knowledgeable

The infrastructure gap has closed. European independence is now practically achievable, not aspirational.

The AI Software Engineering Experiment

This project was also an experiment: Can small teams use AI tooling to build production systems faster?

After six months, the answer: Yes, with important caveats.

What AI accelerated:

Understanding unfamiliar systems: Kubernetes networking, Flux reconciliation loops, cert-manager certificate chains, Gateway API ReferenceGrants—these are complex with subtle interactions.

Traditional learning: Read docs, search Stack Overflow, trial-and-error, eventually understand (days to weeks).

With Claude: Ask specific questions, get explained with context from our codebase, understand in minutes to hours.

Writing boilerplate: OpenTofu modules follow patterns. Kubernetes manifests have structure. Helm values have conventions.

AI excels at generating syntactically correct YAML/HCL from requirements. Review and adjust, but starting point is solid.

Debugging complex issues: Multi-cluster connectivity not working? Certificate chain invalid? DNS resolution failing?

Paste error logs, get probable cause suggestions, faster path to solution. Not magic—still requires verification and understanding—but accelerated.

Documentation transformation: Architecture decisions made in conversations need to become structured documentation. AI helps: raw notes → ADRs, scattered thoughts → coherent guides.

What AI didn't replace:

Architectural decisions: Should we use centralized or per-environment monitoring? Gateway API or stick with Ingress? SOPS or external secret store?

These require understanding tradeoffs, organizational context, resource constraints. AI explains options and tradeoffs, but humans must decide.

Domain expertise: European sovereignty requirements, GDPR implications, regulatory landscape, business model considerations—these require specific knowledge.

AI can explain regulations but can't substitute for compliance expertise or business judgment.

Quality judgment: Is this code maintainable? Will this architecture scale? Is this abstraction premature? Will on-call engineers understand this at 3am?

These require experience and operational wisdom. AI suggests approaches; humans judge appropriateness.

Operational experience: What fails at 3am? What's actually difficult to debug? What causes alert fatigue? These come from running systems, not generating code.

The Honest Assessment

Would we have built this without AI? Yes, but slower. Conservative estimate: 9-12 months instead of 6.

Could a single person do this with AI? Probably not sustainably. On-call burden alone requires multiple people. AI doesn't solve operational load or 24/7 coverage needs.

Is AI necessary for European cloud independence? No. But it's a significant accelerator for small teams learning complex technologies.

What We'd Tell Someone Starting Today

1. Start with Kubernetes It's the portability layer that makes independence possible. Don't build custom orchestration.

2. Use managed services thoughtfully Managed Kubernetes: yes (reduces operational burden). Managed everything: no (creates vendor lock-in). Find the balance.

3. Adopt GitOps immediately Flux creates guardrails that prevent drift. Everything in Git means everything is auditable and reproducible.

4. Test from the beginning Tests are infrastructure for confident changes. 264 API tests took time to write but enable fast, confident refactoring.

5. Leverage AI tooling appropriately AI as learning accelerator and boilerplate generator: excellent. AI replacing engineering judgment: dangerous. Review everything critically.

6. Build on European infrastructure The providers are ready. The gap has closed. You're not sacrificing quality for sovereignty—you're getting both.

The Realistic Timeline

Six months included:

• Learning Kubernetes, Gateway API, Flux, SOPS
• Architectural mistakes and refactoring
• Running a business in parallel
• Building comprehensive test coverage
• Documentation and runbooks

If you're focused full-time with existing Kubernetes knowledge: probably 3-4 months.

If you're learning as you go (like we were): 6-8 months is realistic.

If you're doing this part-time while running a business: 6-12 months.

Set realistic expectations. Speed matters less than getting it right.

Proof Points

After six months, we have:

Technical maturity:

• Multi-cluster GitOps in production
• Centralized observability with year-plus retention
• Rapid security response (CVE patched in 3 hours)
• Zero-downtime deployments via Kubernetes rolling updates

Operational sustainability:

• On-call rotation: 1 week every 2 months (3-person team)
• Incident response: clear runbooks, good monitoring
• Maintenance overhead: manageable for small team

Business viability:

• Competitive pricing vs. hyperscalers
• European jurisdiction simplifies compliance
• Platform proves sovereignty is practical, not just aspirational

This is real. It works. Small teams can do this.

Sources:

• Project git history (2,143 commits June-December 2025)
• Clouds of Europe GitHub Repository

#successstory #kubernetes #gitops #europeancloud #aiassisted