AshaCoreSovereign web platform · built by a team of AI agents
DE
PlatformProductsThe CompanyPilotUse CasesContactDeutsch

Colophon

The engineering behind it.

This site is a working example: the same discipline with which we build the AshaCore platform — only small enough to show in full.

The stack — and why

Every choice is a decision with a reason.

Astro 6

SSG-first · islands

Static by default — every page that doesn't have to be dynamic isn't. Interactivity is added as a targeted island, not as an app-wide runtime.

Svelte 5

exactly one island framework

A single UI library for everything interactive — theme switching and the contact form. Compiled, lean, without virtual-DOM overhead.

Native CSS + design tokens

no Tailwind

One single source of truth for colours, spacing and the type scale. Container queries, logical properties and fluid clamp() scales — the platform itself rather than an abstraction over it.

AshaCore control plane

content backend

Published content can be loaded from a separate control-plane backend. The public website stays lean, while editing, roles and later backend capabilities remain cleanly separated.

Ubuntu server

a controlled runtime

The site runs on its own Ubuntu server. That keeps runtime, logs, configuration and operational decisions traceable — not a black box, but a deliberately controlled environment.

Coolify

self-hosted PaaS

Coolify handles deployment, process management, domain binding, TLS and Git integration for the operated components. Platform convenience, but on our own infrastructure — with clear control over operations and environment.

GitHub + CI/CD

push · check · deploy

Changes don't reach production manually via FTP or a shell copy. Every relevant state is versioned, automatically checked and then delivered in a controlled way.

Type-safe content

Zod · TypeScript strict

Content is modelled, not scattered. Structural errors surface at build time — not at the visitor.

Quality gates

check · lint · test · e2e

astro check, ESLint, Prettier, Vitest and Playwright. Green before every commit — the discipline that makes maintainability possible in the first place.

Principles, visible in the code

Convictions that don't end at words.

Boring technology wins
Astro, Svelte, npm — established tools rather than a bet on the next trend.
Types before runtime
TypeScript strict and Zod schemas. The build is the first code review.
Few, deliberate dependencies
A handful of runtime dependencies. Each one is a documented decision.
Operations are designed in
Frontend and backend have clear responsibilities: public delivery here, editorial backend capabilities in the control plane.
Deployment is architecture
The delivery process isn't an afterthought shell script. Code, build, tests and deployment visibly belong together.
Operations stay traceable
Server logs, build logs and CI output form an auditable chain from commit to running application.
Secrets stay out of the code
Tokens, API keys and productive configuration live in environment variables — not in the repository.

From commit to production

A delivery process that is designed in.

This site isn't just built, it's made deliverable. Changes are made locally, versioned, automatically checked and only then rolled out on the server. The deployment process is part of the architecture — not an afterthought manual step.

Code
Changes are made locally in the project, under the same rules and quality standards as the later build.
GitHub repository
The relevant state is versioned and made traceable, rather than changed directly on the server.
CI gates
Automated checks validate types, linting, tests, build and E2E behaviour before anything ships.
Deploy
Only after successful gates is the checked state delivered in a controlled way.
Build
The application is built reproducibly from the versioned state, including static assets.
Backend
Published content and editorial functions live in the AshaCore control plane.
Live site
What ships is the checked state — observable through build logs, server logs and the running system.

Performance & accessibility

  • No web-font dependency — a carefully chosen system font stack. Instant first paint, no FOUT.
  • Page content is delivered statically; only a handful of small islands become interactive — theme switching and the contact form.
  • Respects prefers-reduced-motion and prefers-color-scheme; theme switching without a flash.
  • Progressive enhancement: without JavaScript, navigation, content and all text remain fully usable.
  • Semantic HTML, focus management, a skip link and full keyboard operation throughout.
  • Static delivery of the public website; backend functions run separately in the control plane.
  • Reproducible builds from a versioned Git state instead of manual server changes.

Security & law

  • Frontend without mail secrets; published content is read via the control plane.
  • Secrets exclusively via environment variables — never in the repository.
  • Controlled rollout: green CI gates first (check · lint · test · build · e2e), then automatic deploy — no untested code in production.
  • Content security policy prepared via the native Astro 6 API.
  • Deployment via GitHub Actions and Coolify: check first, then ship.
  • Productive secrets live exclusively in the runtime environment and are not committed.
  • The public site describes principles — no webhook URLs, tokens, admin paths or productive details.

None of this is spectacular — and that's exactly the point. Software meant to last years doesn't win through the newest thing, but through clear, justified and observable decisions. The stack is only the visible surface. It gets interesting where code is reliably built, checked, shipped and operated.Let's talk about it.