diff --git a/.gitea/workflows/deploy.yml b/.gitea/workflows/deploy.yml
index c7bd7f4..abef024 100644
--- a/.gitea/workflows/deploy.yml
+++ b/.gitea/workflows/deploy.yml
@@ -472,36 +472,30 @@ jobs:
exit 1
fi
- - name: 🌐 Check Case Study Assets and Rewrites
+ - name: 🌐 Check Legal Pages and Old URLs
shell: sh
run: |
BASE_URL="${{ needs.prepare.outputs.next_public_url }}"
- echo "Verifying case study page..."
- STATUS=$(curl -s -o /dev/null -w "%{http_code}" "$BASE_URL/case-studies/klz-cables")
- if [ "$STATUS" != "200" ]; then
- echo "❌ Case study page failed! (Status: $STATUS)"
- exit 1
- fi
- echo "✅ Case study page UP"
+ # The legal pages must be reachable.
+ for PAGE in /imprint /privacy; do
+ STATUS=$(curl -s -o /dev/null -w "%{http_code}" "$BASE_URL$PAGE")
+ if [ "$STATUS" != "200" ]; then
+ echo "❌ $PAGE failed! (Status: $STATUS)"
+ exit 1
+ fi
+ echo "✅ $PAGE OK"
+ done
- echo "Verifying breeze CSS (root path)..."
- CSS_PATH="/assets/klz-cables.com/wp-content/cache/breeze-minification/css/breeze_klz-cables-com-1-10895.css"
- STATUS=$(curl -s -o /dev/null -w "%{http_code}" "$BASE_URL$CSS_PATH")
- if [ "$STATUS" != "200" ]; then
- echo "❌ Root asset path failed! (Status: $STATUS)"
- exit 1
- fi
- echo "✅ Root asset path OK"
-
- echo "Verifying breeze CSS (relative path from case-study)..."
- REL_CSS_PATH="/case-studies/assets/klz-cables.com/wp-content/cache/breeze-minification/css/breeze_klz-cables-com-1-10895.css"
- STATUS=$(curl -s -o /dev/null -w "%{http_code}" "$BASE_URL$REL_CSS_PATH")
- if [ "$STATUS" != "200" ]; then
- echo "❌ Relative asset path failed! (Status: $STATUS)"
- exit 1
- fi
- echo "✅ Relative asset path OK"
+ # URLs of the previous site must redirect instead of returning 404.
+ for OLD in /blog /contact /websites /case-studies/klz-cables /impressum; do
+ STATUS=$(curl -s -o /dev/null -w "%{http_code}" "$BASE_URL$OLD")
+ if [ "$STATUS" != "308" ]; then
+ echo "❌ $OLD does not redirect! (Status: $STATUS)"
+ exit 1
+ fi
+ echo "✅ $OLD redirects"
+ done
# ──────────────────────────────────────────────────────────────────────────────
# JOB 6: Notifications
diff --git a/CLAUDE.md b/CLAUDE.md
index 5cb4e22..b726477 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -20,6 +20,19 @@ App lives in `apps/web`. Concept and scope: `apps/web/plans/freelance-relaunch.m
5. Report the exact commands and results. "Done" means they were run on the current code.
Never weaken, skip or delete a test to make it pass.
+## Copy rules (client-facing pages)
+
+- Never mention AI as the owner's tool, and no internal method vocabulary (specs, TDD, mutation, coverage,
+ pull requests). The automation service may name AI as part of what the client gets. Plain language.
+- Modest and factual: no promises the owner did not confirm, no superlatives. See the concept, section 1.
+- One page: everything lives on the homepage. The header has only "Get in touch", which jumps to the contact
+ section (`#contact`). Contact is one email address: no calendar integration, no form. The only other
+ pages are `/imprint` and `/privacy`. URLs of the previous site redirect to `/` (see `next.config.mjs`).
+- The email address is kept in parts (`src/content/site.ts`) and assembled in the browser by `EmailLink`.
+ Never write the full address into markup, metadata or copy.
+- The hero design (binary-digit headline) is approved: do not change its design.
+- Look at the result before reporting: take screenshots (desktop and mobile), do not ship blind.
+
## Architecture rules
- Functional core, imperative shell. Pure logic goes in `apps/web/src/domain/` (no I/O, no clock, no
@@ -40,7 +53,12 @@ App lives in `apps/web`. Concept and scope: `apps/web/plans/freelance-relaunch.m
## Gotchas
+- `tsconfig` includes `.next/types`: after deleting a route, stale generated files there break `tsc`.
+ Run `next typegen` and remove the stale file.
+- Run only one Stryker process at a time; parallel runs share `.stryker-tmp` and hang.
- Stryker needs `plugins` listed explicitly in `stryker.config.json` (pnpm layout) and ignores the large
asset folders via `ignorePatterns`; keep them in sync when adding top-level folders.
-- `@mintel/*` packages are `link:` dependencies on a sibling `at-mintel` checkout.
+- `@mintel/*` packages are `link:` dependencies on a sibling `at-mintel` checkout. The app itself now only
+ uses `@mintel/next-config`; the other entries in `package.json` are leftovers from the old site.
+- Pushing `main` deploys to the testing environment; production is deployed from a `v*` tag.
- Git branches: work on `feat/*`, never directly on `main`.
diff --git a/apps/web/app/(site)/about/page.tsx b/apps/web/app/(site)/about/page.tsx
deleted file mode 100644
index fbaaf18..0000000
--- a/apps/web/app/(site)/about/page.tsx
+++ /dev/null
@@ -1,71 +0,0 @@
-import type { Metadata } from "next";
-import { Container, SectionHeader } from "@/src/components/site";
-import { Timeline } from "@/src/components/about/Timeline";
-import { TagList } from "@/src/components/about/TagList";
-import {
- NOT_MY_THING,
- STACK_ITEMS,
- TIMELINE,
- WORKING_MODE,
-} from "@/src/components/about/aboutData";
-
-export const metadata: Metadata = {
- title: "About",
- description:
- "Senior engineer who makes AI-built software dependable. Web since 2011, remote since 2021, now independent.",
- alternates: { canonical: "/about" },
-};
-
-// TODO(owner): link a CV download here once the PDF exists (no file yet).
-
-export default function Page() {
- return (
-
-
-
-
-
- I have worked on the web since 2011, starting with an apprenticeship.
- Since then I have worked in agencies and product companies, and led
- the frontend team at an agency. I have been fully remote since 2021
- and am now independent, while running a small product business.
-
-
- Design and frontend are my strength. I am comfortable with backend
- concepts and architecture. Today I mostly write TypeScript and
- Next.js, plus Rust and Solidity for systems work. The path started
- with Vue and plain JavaScript, and I would rather say so than pretend
- I always wrote Rust.
-
-
-
-
-
- How I work
-
-
- {WORKING_MODE.map((line) => (
-
{line}
- ))}
-
-
-
-
-
- Timeline
-
-
-
-
-
-
-
-
-
- );
-}
diff --git a/apps/web/app/(site)/blog/[slug]/opengraph-image.tsx b/apps/web/app/(site)/blog/[slug]/opengraph-image.tsx
deleted file mode 100644
index 5866d5e..0000000
--- a/apps/web/app/(site)/blog/[slug]/opengraph-image.tsx
+++ /dev/null
@@ -1,70 +0,0 @@
-import { ImageResponse } from "next/og";
-import { getAllPosts } from "../../../../src/lib/posts";
-import { blogThumbnails } from "../../../../src/components/blog/blogThumbnails";
-import { BlogOGImageTemplate } from "../../../../src/components/BlogOGImageTemplate";
-import { getOgFonts, OG_IMAGE_SIZE } from "../../../../src/lib/og-helper";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-
-export const size = OG_IMAGE_SIZE;
-export const contentType = "image/png";
-export const runtime = "nodejs";
-
-export default async function Image({
- params,
-}: {
- params: Promise<{ slug: string }>;
-}) {
- const { slug } = await params;
- const allPosts = await getAllPosts();
- const post = allPosts.find((p) => p.slug === slug);
-
- let backgroundImageSrc: string | undefined = undefined;
-
- // If we have a custom generated thumbnail, convert it to a data URI for Satori
- if (post?.thumbnail) {
- try {
- const filePath = path.join(process.cwd(), "public", post.thumbnail);
- const fileBuffer = await fs.readFile(filePath);
-
- const ext = path.extname(post.thumbnail).substring(1).toLowerCase();
- const mimeType =
- ext === "jpg" || ext === "jpeg" ? "image/jpeg" : "image/png";
-
- backgroundImageSrc = `data:${mimeType};base64,${fileBuffer.toString("base64")}`;
- } catch (err) {
- console.warn(
- `[OG Image Generator] Could not read thumbnail file for ${slug} to use as background:`,
- err,
- );
- // Fall through to standard plain background
- }
- }
-
- const thumbnail = blogThumbnails[slug];
-
- const title = post?.title || "Marc Mintel";
- const description =
- post?.description ||
- "Technical problem solver's blog - practical insights and learning notes";
- const label = post ? "Blog Post" : "Engineering";
- const accentColor = thumbnail?.accent;
- const keyword = thumbnail?.keyword;
-
- const fonts = await getOgFonts();
-
- return new ImageResponse(
- ,
- {
- ...OG_IMAGE_SIZE,
- fonts: fonts as any,
- },
- );
-}
diff --git a/apps/web/app/(site)/blog/[slug]/page.tsx b/apps/web/app/(site)/blog/[slug]/page.tsx
deleted file mode 100644
index ebdbc67..0000000
--- a/apps/web/app/(site)/blog/[slug]/page.tsx
+++ /dev/null
@@ -1,119 +0,0 @@
-import * as React from "react";
-import type { Metadata } from "next";
-import { notFound, redirect } from "next/navigation";
-
-import { getAllPosts } from "@/src/lib/posts";
-import { BlogPostHeader } from "@/src/components/blog/BlogPostHeader";
-import { Section } from "@/src/components/Section";
-import { Reveal } from "@/src/components/Reveal";
-import { BlogPostClient } from "@/src/components/BlogPostClient";
-import { TextSelectionShare } from "@/src/components/TextSelectionShare";
-import { BlogPostStickyBar } from "@/src/components/blog/BlogPostStickyBar";
-import { MDXContent } from "@/src/components/MDXContent";
-
-import { TableOfContents } from "@/src/components/TableOfContents";
-
-export async function generateStaticParams() {
- const allPosts = await getAllPosts();
- return allPosts.map((post) => ({
- slug: post.slug,
- }));
-}
-
-export async function generateMetadata({
- params,
-}: {
- params: Promise<{ slug: string }>;
-}): Promise {
- const { slug } = await params;
- const allPosts = await getAllPosts();
- const post = allPosts.find((p) => p.slug === slug);
-
- if (!post) return {};
-
- return {
- title: post.title,
- description: post.description,
- openGraph: {
- title: post.title,
- description: post.description,
- type: "article",
- },
- twitter: {
- card: "summary_large_image",
- title: post.title,
- description: post.description,
- },
- };
-}
-
-export default async function BlogPostPage({
- params,
-}: {
- params: Promise<{ slug: string }>;
-}) {
- const { slug } = await params;
- const allPosts = await getAllPosts();
- const post = allPosts.find((p) => p.slug === slug);
-
- if (!post) {
- notFound();
- }
-
- const formattedDate = new Date(post.date).toLocaleDateString("de-DE", {
- month: "long",
- day: "numeric",
- year: "numeric",
- });
-
- const wordCount = post.description.split(/\s+/).length + 300;
- const readingTime = Math.max(1, Math.ceil(wordCount / 200));
-
- return (
-
-
- Engineering eines
- Systems.
-
-
- Vom statischen Altsystem zum industriellen Standard. Ich
- habe das KLZ-System auf das Wesentliche reduziert: Hardened
- Infrastructure, parametrische Datenpflege und zero
- maintenance.
-
-
-
- Vom statischen HTML zur zentralen Daten-Instanz.
-
-
- Ich habe die KLZ-Architektur radikal auf einen entkoppelten
- High-Performance-Stack umgestellt. WordPress fungiert hier
- nicht als CMS-Baukasten, sondern speichert alle technischen
- Attribute in einer zentralen relationalen Instanz. Durch die
- Implementierung nativer PHP-Services und den Verzicht auf
- volatile Drittanbieter-Plugins wurde ein System geschaffen,
- das keine technologischen Überraschungen zulässt. Stability by{" "}
- Design.
-
-
-
-
- Für Hochspannungs-N2XS(F)2Y Kabel ist Datentreue eine
- Sicherheitsanforderung. Ich habe eine automatisierte
- Asset-Pipeline entwickelt, die technische Datenblätter
- serverseitig generiert und validiert.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Fokus auf
- Spezifikationen.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Der Produktbereich wurde konsequent auf die Bedürfnisse
- technischer Planer optimiert. Klare Hierarchien und der
- Verzicht auf E-Commerce-Rauschen ermöglichen einen direkten
- Zugriff auf Kabel-Parameter und Datenblätter.
-
-
-
-
- Strukturierte Aufbereitung technischer Produktdaten.
-
-
-
-
- Die News-Engine dient als technischer Hub für
- Industrie-Standards. Durch die Implementierung eines
- performanten Blog-Systems wird Fachwissen direkt an die
- Zielgruppe kommuniziert.
-
-
-
- Die Migration von einer statischen Datei-Struktur zu einer
- zentralisierten Daten-Instanz eliminiert technische Schulden und
- manuelle Fehlerquellen. Das Ergebnis ist eine wartungsfreie
- Architektur, die technische Datentreue über den gesamten
- Produkt-Lifecycle sicherstellt.
-
-
-
-
-
-
-
-
-
-
-
-
-
- {/* --- SECTION 06: CONVERSION --- */}
-
-
-
-
-
-
-
- Direkter Draht.
-
-
- Das Kontakt-System wurde auf maximale Reduktion getrimmt. Ein
- deterministischer Kanal zwischen technischem Bedarf und
- individueller Beratung – ohne Umwege, ohne Rauschen.
-
-
-
-
-
-
-
-
- RESPONSE_TIME
-
-
- < 120ms
-
-
-
-
- PROTOCOL
-
-
- mTLS
-
-
-
-
- AVAILABILITY
-
-
- 99.9%
-
-
-
-
- ENCRYPTION
-
-
- AES-256
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- {/* --- FINAL CTA: ARCHITECTURE & VALUE --- */}
-
-
-
-
-
-
-
-
- CONSULTING // ENGINEERING
-
-
- Architektur
- ohne Altlasten.
-
-
-
-
-
- Vom Prototyp zum industriellen Standard. Ich entwickle
- digitale Infrastrukturen, die technische Freiheit und
- operative Stabilität garantieren – wartungsfrei und
- skalierbar.
-
-
-
+ VAT identification number according to section 27a of the German VAT
+ Act (Umsatzsteuergesetz): {OWNER.vatId}
+
+
+
+
+
{OWNER.name}, address as above (section 18 paragraph 2 MStV).
+
+
+
+
+ I am neither willing nor obliged to take part in dispute resolution
+ proceedings before a consumer arbitration board.
+
+
+
+ );
+}
diff --git a/apps/web/app/(site)/layout.tsx b/apps/web/app/(site)/layout.tsx
index 3d82c4f..e3d6e8b 100644
--- a/apps/web/app/(site)/layout.tsx
+++ b/apps/web/app/(site)/layout.tsx
@@ -19,25 +19,14 @@ const newsreader = Newsreader({
display: "swap",
});
-const DESCRIPTION =
- "Senior engineer for teams that build fast with AI and don't want chaos. Strong in design and frontend, provably clean in architecture and tests. Remote, booked in weekly capacity blocks.";
-
export const metadata: Metadata = {
title: {
- default: "Marc Mintel — Senior engineer for AI-built software",
+ default: "Marc Mintel — Senior developer for web apps and websites",
template: "%s | Marc Mintel",
},
- description: DESCRIPTION,
+ description:
+ "Senior developer for web apps, interfaces and websites. Book weekly hours for your product, get an unreliable app back on track, or have a website built for you.",
metadataBase: new URL("https://mintel.me"),
- openGraph: {
- type: "website",
- siteName: "Marc Mintel",
- title: "Marc Mintel — Senior engineer for AI-built software",
- description: DESCRIPTION,
- url: "https://mintel.me",
- locale: "en_US",
- },
- twitter: { card: "summary_large_image" },
icons: {
icon: "/favicon.svg",
},
@@ -51,9 +40,9 @@ export default function RootLayout({
return (
-
+
{children}
diff --git a/apps/web/app/(site)/legal/layout.tsx b/apps/web/app/(site)/legal/layout.tsx
deleted file mode 100644
index 1191fef..0000000
--- a/apps/web/app/(site)/legal/layout.tsx
+++ /dev/null
@@ -1,9 +0,0 @@
-import { LegacyLightSurface } from "@/src/components/LegacyLightSurface";
-
-export default function LegacyLayout({
- children,
-}: {
- children: React.ReactNode;
-}) {
- return {children};
-}
diff --git a/apps/web/app/(site)/notes/[slug]/page.tsx b/apps/web/app/(site)/notes/[slug]/page.tsx
deleted file mode 100644
index ea44bb3..0000000
--- a/apps/web/app/(site)/notes/[slug]/page.tsx
+++ /dev/null
@@ -1,91 +0,0 @@
-import type { Metadata } from "next";
-import Link from "next/link";
-import { notFound } from "next/navigation";
-import { Container, Pill } from "@/src/components/site";
-import { NOTES } from "@/src/content/notes";
-import { SITE_NAME, SITE_URL } from "@/src/content/site";
-import { findNoteBySlug } from "@/src/domain/notes";
-
-type PageProps = { readonly params: Promise<{ readonly slug: string }> };
-
-export const dynamicParams = false;
-
-export function generateStaticParams() {
- return NOTES.map((note) => ({ slug: note.slug }));
-}
-
-export async function generateMetadata({
- params,
-}: PageProps): Promise {
- const found = findNoteBySlug(NOTES, (await params).slug);
- if (!found.ok) return {};
- const { title, summary, slug, publishedOn } = found.value;
- const path = `/notes/${slug}`;
- return {
- title,
- description: summary,
- alternates: { canonical: path },
- openGraph: {
- type: "article",
- title,
- description: summary,
- url: path,
- publishedTime: publishedOn,
- },
- };
-}
-
-export default async function Page({ params }: PageProps) {
- const found = findNoteBySlug(NOTES, (await params).slug);
- if (!found.ok) notFound();
- const { Body, title, summary, slug, publishedOn, readingMinutes, tags } =
- found.value;
-
- const jsonLd = {
- "@context": "https://schema.org",
- "@type": "Article",
- headline: title,
- description: summary,
- datePublished: publishedOn,
- url: `${SITE_URL}/notes/${slug}`,
- author: { "@type": "Person", name: SITE_NAME, url: SITE_URL },
- keywords: tags.join(", "),
- };
-
- return (
-
-
-
-
- ← Notes
-
-
-
- {title}
-
-
-
- {" · "}
- {readingMinutes} min read
-
-
- {tags.map((tag) => (
- {tag}
- ))}
-
-
-
-
-
-
-
- );
-}
diff --git a/apps/web/app/(site)/notes/page.tsx b/apps/web/app/(site)/notes/page.tsx
deleted file mode 100644
index a87715c..0000000
--- a/apps/web/app/(site)/notes/page.tsx
+++ /dev/null
@@ -1,51 +0,0 @@
-import type { Metadata } from "next";
-import Link from "next/link";
-import { Container, Pill, SectionHeader } from "@/src/components/site";
-import { NOTES } from "@/src/content/notes";
-
-export const metadata: Metadata = {
- title: "Notes",
- description:
- "Evergreen engineering write-ups with diagrams: verification, architecture and testing.",
- alternates: { canonical: "/notes" },
-};
-
-export default function Page() {
- return (
-
-
-
- {NOTES.map((note) => (
-
-
-
-
- {" · "}
- {note.readingMinutes} min read
-
-
- {note.title}
-
-
- {note.summary}
-
-
- {note.tags.map((tag) => (
- {tag}
- ))}
-
-
-
- ))}
-
-
- );
-}
diff --git a/apps/web/app/(site)/opengraph-image.tsx b/apps/web/app/(site)/opengraph-image.tsx
index db33a01..3f284de 100644
--- a/apps/web/app/(site)/opengraph-image.tsx
+++ b/apps/web/app/(site)/opengraph-image.tsx
@@ -12,8 +12,8 @@ export default async function Image() {
return new ImageResponse(
,
{
...OG_IMAGE_SIZE,
diff --git a/apps/web/app/(site)/page.tsx b/apps/web/app/(site)/page.tsx
index eb085a9..c05f8f1 100644
--- a/apps/web/app/(site)/page.tsx
+++ b/apps/web/app/(site)/page.tsx
@@ -1,44 +1,314 @@
import type { Metadata } from "next";
-import { BuiltAndRunning } from "@/src/components/home/BuiltAndRunning";
-import { CapacityBlocks } from "@/src/components/home/CapacityBlocks";
-import { FinalCta } from "@/src/components/home/FinalCta";
-import { Hero } from "@/src/components/home/Hero";
+import { Block } from "@/src/components/home/Block";
+import { ClosingCta } from "@/src/components/home/ClosingCta";
+import { Faq } from "@/src/components/home/Faq";
+import { HeroStatement } from "@/src/components/home/HeroStatement";
import { HomeJsonLd } from "@/src/components/home/HomeJsonLd";
-import { HowIShip } from "@/src/components/home/HowIShip";
-import { ProofStrip } from "@/src/components/home/ProofStrip";
-import { WebsitesSection } from "@/src/components/home/WebsitesSection";
-import { WhatIDo } from "@/src/components/home/WhatIDo";
-import { SITE_NAME } from "@/src/content/site";
-
-const TITLE = `${SITE_NAME}: senior engineer for AI-built software`;
-const DESCRIPTION =
- "Senior engineer for teams that build fast with AI and don't want chaos. Spec-first, test-driven, mutation-checked. Booked in weekly capacity blocks.";
+import { PathPicker } from "@/src/components/home/PathPicker";
+import { PortraitSection } from "@/src/components/home/PortraitSection";
+import { StickyBook } from "@/src/components/home/StickyBook";
+import { AutomationFlow } from "@/src/components/illustrations/AutomationFlow";
+import { CareerLine } from "@/src/components/illustrations/CareerLine";
+import { ContactDiagram } from "@/src/components/illustrations/ContactDiagram";
+import { PipelineRun } from "@/src/components/illustrations/PipelineRun";
+import {
+ WorkShowcase,
+ type WorkItem,
+} from "@/src/components/illustrations/WorkShowcase";
+import { Reveal } from "@/src/components/Reveal";
+import { CAREER, FIT, TECH } from "@/src/content/about";
+import { AUTOMATION_NOTES } from "@/src/content/automation";
export const metadata: Metadata = {
- title: { absolute: TITLE },
- description: DESCRIPTION,
+ title: "Marc Mintel — Senior developer for web apps and websites",
+ description:
+ "Freelance developer with 15 years of experience. I build web apps, interfaces and websites: by the hour for product teams, or a complete website for your business.",
alternates: { canonical: "/" },
- openGraph: {
- title: TITLE,
- description: DESCRIPTION,
- url: "/",
- type: "website",
- siteName: SITE_NAME,
- },
};
-export default function HomePage() {
+const MUTED = "text-slate-400";
+const BODY = "m-0 font-sans text-lg leading-relaxed text-slate-500 md:text-xl";
+const MONO = "font-mono text-[11px] uppercase tracking-[0.2em] text-slate-500";
+
+const PRINCIPLES = [
+ {
+ title: "One contact",
+ text: "You talk to me, and I am the one who does the work.",
+ },
+ {
+ title: "Hours you can check",
+ text: "I track my time. The monthly invoice shows what the hours were spent on.",
+ },
+ {
+ title: "Careful work",
+ text: "I test what I build before I hand it over, and I say so when something is not finished or I am not sure.",
+ },
+ {
+ title: "What I build is yours",
+ text: "Code and design belong to you. You can hand them to another developer.",
+ },
+] as const;
+
+const WORK: readonly WorkItem[] = [
+ {
+ name: "klz-cables.com",
+ href: "https://klz-cables.com",
+ client: "Cable supplier",
+ text: "The company website of a supplier of energy cables, in German and English.",
+ did: [
+ "Product catalogue with categories and detail pages",
+ "Datasheets generated from the product data",
+ "Content the client can edit in a CMS",
+ ],
+ tech: ["Next.js", "TypeScript", "Headless CMS", "Two languages"],
+ desktop: { src: "/work/klz-long.webp", width: 1200, height: 1680 },
+ mobile: { src: "/work/klz-mobile.webp", width: 390, height: 3600 },
+ },
+ {
+ name: "e-tib.com",
+ href: "https://e-tib.com",
+ client: "Cable network construction",
+ text: "The company website of a group in cable network construction, in German and English.",
+ did: [
+ "Pages for services, references, careers and events",
+ "The same content in two languages",
+ "Works on phone, tablet and desktop",
+ ],
+ tech: ["Next.js", "TypeScript", "Headless CMS", "Two languages"],
+ desktop: { src: "/work/etib-long.webp", width: 1200, height: 4333 },
+ mobile: { src: "/work/etib-mobile.webp", width: 390, height: 3600 },
+ },
+];
+
+export default function LandingPage() {
return (
- <>
+
-
-
-
-
-
-
-
-
- >
+
+
+
+ I am Marc.>}
+ >
+
+ I have been building for the web for 15 years: first in agencies,
+ later as a senior developer, and now on my own.
+
+
+ My strength is the part people see and use: design and interface. I am
+ also at home with what lies behind it, so I can build a complete
+ application and not just its surface.
+
+
+ You work with me directly. Whether you run a product team or are
+ commissioning something like this for the first time.
+
+
+
+
+
+
The path so far
+
+
+
+
+
+ What do you need? Four typical cases.
+ >
+ }
+ >
+
+
+
+
+
+
+ Let the systems do the copying.
+ >
+ }
+ >
+
+
+ In most companies, people move information from one tool to another:
+ read it here, type it in there, send an email about it. Automation
+ connects those tools so that the work passes from one to the next on
+ its own. Three typical examples:
+
+
+
+
+
+
+ {AUTOMATION_NOTES.map((group, i) => (
+
+
+
{group.title}
+
+ {group.items.map((item) => (
+
+ {item}
+
+ ))}
+
+
+
+ ))}
+
+
+
+
+ Which projects I am right for.
+ >
+ }
+ >
+
+ {FIT.map((group, i) => (
+
+
+
{group.title}
+
+ {group.items.map((item) => (
+
+ {item}
+
+ ))}
+
+
+
+ ))}
+
+
+
+
+
What I work with
+
+ {TECH.map((group) => (
+
+
+ {group.area}
+
+
+ {group.items.map((item) => (
+
+ {item}
+
+ ))}
+
+
+ ))}
+
+
+
+
+
+
+
+ What happens before a change goes live.
+
+
+ Software is connected: a change in one place can break another. I
+ secure what I build with automated tests, and every change has to
+ pass them before it is released. This is what such a run looks
+ like.
+
+
+
+
+
+
+
+
+
+ How I work. Nothing unusual.
+ >
+ }
+ >
+
+
+
+
+
+
+ {PRINCIPLES.map((item, i) => (
+
+
+
+ {item.title}
+
+
{item.text}
+
+
+ ))}
+
+
+
+
+ Two sites I built. Both are live.
+ >
+ }
+ >
+
+
+
+ Besides client work I build my own software, among other things a
+ system in Rust and Solidity that runs on seven blockchains.
+
+
+
+
+
+ Good to know before we talk.
+ >
+ }
+ >
+
+
+
+
+
+
+
);
}
diff --git a/apps/web/app/(site)/privacy/page.tsx b/apps/web/app/(site)/privacy/page.tsx
new file mode 100644
index 0000000..1021b17
--- /dev/null
+++ b/apps/web/app/(site)/privacy/page.tsx
@@ -0,0 +1,97 @@
+import type { Metadata } from "next";
+import { EmailLink } from "@/src/components/EmailLink";
+import { LegalPage, LegalSection } from "@/src/components/LegalPage";
+import { OWNER } from "@/src/content/site";
+
+export const metadata: Metadata = {
+ title: "Privacy",
+ description: "How mintel.me handles personal data.",
+ alternates: { canonical: "/privacy" },
+ robots: { index: false, follow: true },
+};
+
+const LINK = "font-bold text-slate-900 underline-offset-4 hover:underline";
+
+export default function PrivacyPage() {
+ return (
+
+
+
+ This website sets no cookies, shows no advertising and includes no
+ content from third parties. Fonts and images are served from this
+ website itself.
+
+
+
+
+
+ When you open a page, the server processes technical data that your
+ browser sends: your IP address, the time, the page requested and the
+ browser type. This is necessary to deliver the website and to keep it
+ secure. The legal basis is my legitimate interest in running the
+ website (Article 6(1)(f) GDPR).
+
+
+
+
+
+ I count page views with Umami, which I run on my own server. It works
+ without cookies and does not create profiles of individual visitors.
+ The data is not passed on to third parties. The legal basis is my
+ legitimate interest in understanding how the website is used (Article
+ 6(1)(f) GDPR).
+
+
+
+
+
+ If something on this website fails technically, an error report is
+ sent to an error tracking service that I run on my own server. It
+ contains technical details such as the page, the browser and the error
+ message. Sessions are not recorded. The legal basis is my legitimate
+ interest in a working website (Article 6(1)(f) GDPR).
+
+
+
+
+
+ If loading a page fails, the website stores a timestamp in your
+ browser's session storage so that it reloads only once. It is
+ deleted when you close the tab and is not sent anywhere.
+
+
+
+
+
+ If you send me an email, I process what you write and your address in
+ order to answer you and, if it comes to that, to prepare a contract
+ (Article 6(1)(b) GDPR). I keep the correspondence for as long as it is
+ needed for that purpose or as the law requires.
+
+
+
+
+
You have the right to:
+
+
ask what data I hold about you
+
have incorrect data corrected
+
have your data deleted or its processing restricted
+
object to processing that is based on legitimate interest
+
receive your data in a portable format
+
complain to a data protection supervisory authority
+
+
+ To use any of these rights, write to .
+
+
+
+ );
+}
diff --git a/apps/web/app/(site)/process/page.tsx b/apps/web/app/(site)/process/page.tsx
deleted file mode 100644
index af37b9e..0000000
--- a/apps/web/app/(site)/process/page.tsx
+++ /dev/null
@@ -1,164 +0,0 @@
-import type { Metadata } from "next";
-import {
- ButtonLink,
- Container,
- SectionHeader,
- TerminalCard,
-} from "@/src/components/site";
-import { ProcessStepCard } from "@/src/components/process/ProcessStepCard";
-import { PROCESS_STEPS } from "@/src/components/process/processSteps";
-import { SAMPLE_DELIVERY_REPORT } from "@/src/components/process/sampleDeliveryReport";
-import { formatDeliveryReport } from "@/src/domain/deliveryReport";
-
-const TITLE = "Process: AI speed, engineering proof";
-const DESCRIPTION =
- "How I ship AI-accelerated code that holds up: spec first, red, green, mutation check and a delivery report with exact commands and results on every pull request.";
-
-export const metadata: Metadata = {
- title: TITLE,
- description: DESCRIPTION,
- alternates: { canonical: "/process" },
- openGraph: {
- title: TITLE,
- description: DESCRIPTION,
- url: "/process",
- type: "website",
- },
-};
-
-const GUARDRAILS = [
- {
- title: "Pre-commit gate",
- text: "Formatting and lint on staged files, then typecheck and the unit tests, run before a commit is created. Broken code does not enter history.",
- },
- {
- title: "Pre-push gate",
- text: "Coverage runs before a push leaves my machine, and the mutation check runs when the domain logic changed. The remote only receives green work.",
- },
- {
- title: "CI gates the deploy",
- text: "On client projects the same checks run again in CI, and a deploy only starts when they pass. My machine is not the only line of defense.",
- },
- {
- title: "Tests are never weakened",
- text: "If a test blocks a change, I do not skip, loosen or delete it to get green. If the test is wrong, I tell you why and the spec changes with your agreement.",
- },
-] as const;
-
-const reportLines = formatDeliveryReport(SAMPLE_DELIVERY_REPORT);
-
-export default function Page() {
- return (
-
-
-
-
-
- The five steps
-
-
- One running example: parsing an availability, meaning a date and
- weekly hours. The date 2026-02-30 must be rejected, 2028-02-29 must be
- accepted, and 168 hours is the upper boundary of a week.
-
- AI-built code often arrives with few tests, or with tests that only
- repeat the implementation. I do not start by rewriting. I write the
- expected behavior as cases for the parts that matter most, run them
- against the existing code, and let the failures show what is really
- broken. Then I add a mutation baseline so you can see which tests
- would not notice a bug.
-
-
Why mutation testing
-
- Coverage tells you which lines ran during the tests. It does not tell
- you whether the tests would notice a bug in those lines. Mutation
- testing changes the code on purpose and checks that a test fails. That
- is the question you care about. Coverage stays useful as a gap finder:
- it points at code nothing exercises. It is not a goal, and a high
- number alone proves little.
-
-
- Two systems where I run this: a Rust and Solidity liquidation system
- across 7 chains, with a zero-survivor mutation gate and a coverage
- ratchet, and the domain core of this website, which has its own tests
- and mutation gate.
-
-
-
-
-
-
- {GUARDRAILS.map((item) => (
-
-
- {item.title}
-
-
- {item.text}
-
-
- ))}
-
-
-
-
-
Want this on your codebase?
-
- A 20-minute intro call is enough to see whether this fits your team.
-
- );
-}
diff --git a/apps/web/app/(site)/technologies/[slug]/data.tsx b/apps/web/app/(site)/technologies/[slug]/data.tsx
deleted file mode 100644
index 35a7589..0000000
--- a/apps/web/app/(site)/technologies/[slug]/data.tsx
+++ /dev/null
@@ -1,95 +0,0 @@
-import { Layers, Code, Database, Palette, Terminal } from "lucide-react";
-
-export interface TechInfo {
- title: string;
- subtitle: string;
- description: string;
- icon: any; // React.ElementType
- benefits: string[];
- customerValue: string;
- color: string;
- related: { name: string; slug: string }[];
-}
-
-export const technologies: Record = {
- "next-js-14": {
- title: "Next.js 14",
- subtitle: "The React Framework for the Web",
- description:
- "Next.js 14 is the latest version of the industry-leading framework for building high-performance web applications. It allows me to create fast, scalable, and search-engine-friendly websites by rendering content on the server before sending it to your users.",
- icon: Layers,
- benefits: [
- "Lightning-fast page loads with Server Components",
- "Automatic image optimization",
- "Instant navigation between pages",
- "Top-tier SEO (Search Engine Optimization) out of the box",
- ],
- customerValue:
- "For my clients, Next.js means a website that ranks higher on Google, keeps visitors engaged with instant interactions, and scales effortlessly as your traffic grows.",
- color: "bg-black text-white",
- related: [
- { name: "TypeScript", slug: "typescript" },
- { name: "React", slug: "react" },
- ],
- },
- typescript: {
- title: "TypeScript",
- subtitle: "JavaScript with Syntax for Types",
- description:
- "TypeScript adds a powerful type system to JavaScript, catching errors before they ever reach production. It acts as a safety net for your code, ensuring that data flows exactly as expected through your entire application.",
- icon: Code,
- benefits: [
- "Eliminates whole categories of common bugs",
- "Makes large codebases easier to maintain",
- "Improves developer productivity and code confidence",
- "Ensures critical data integrity",
- ],
- customerValue:
- 'Using TypeScript means your application is robust and reliable from day one. It dramatically reduces the risk of "runtime errors" that could crash your site, saving time and money on bug fixes down the line.',
- color: "bg-blue-600 text-white",
- related: [
- { name: "Next.js 14", slug: "next-js-14" },
- ],
- },
-
- "tailwind-css": {
- title: "Tailwind CSS",
- subtitle: "Utility-First CSS Framework",
- description:
- "Tailwind CSS is a utility-first framework that allows me to build custom designs directly in markup. It eliminates the need for bulky, overriding stylesheets and ensures a consistent design system across every page.",
- icon: Palette,
- benefits: [
- "Rapid UI development and prototyping",
- "Consistent spacing, colors, and typography",
- "Highly optimized final bundle size (only includes used styles)",
- "Responsive design made simple",
- ],
- customerValue:
- "Tailwind ensures your brand looks pixel-perfect on every device. It also results in incredibly small CSS files, meaning your site loads faster for users on mobile networks.",
- color: "bg-cyan-500 text-white",
- related: [
- { name: "React", slug: "react" },
- { name: "Next.js 14", slug: "next-js-14" },
- ],
- },
- react: {
- title: "React",
- subtitle: "The Library for Web and Native User Interfaces",
- description:
- "React is the core library powering Next.js. It lets me build encapsulated components that manage their own state, then compose them to make complex UIs.",
- icon: Terminal,
- benefits: [
- "Component-based architecture for reuse",
- "Efficient updates and rendering",
- "Rich ecosystem of libraries and tools",
- "Strong community support",
- ],
- customerValue:
- "React enables rich, app-like interactions on your website. Whether it's a complex dashboard or a smooth animation, React makes it possible to build dynamic experiences that feel instantaneous.",
- color: "bg-blue-400 text-white",
- related: [
- { name: "Next.js 14", slug: "next-js-14" },
- { name: "Tailwind CSS", slug: "tailwind-css" },
- ],
- },
-};
diff --git a/apps/web/app/(site)/technologies/[slug]/page.tsx b/apps/web/app/(site)/technologies/[slug]/page.tsx
deleted file mode 100644
index 6603986..0000000
--- a/apps/web/app/(site)/technologies/[slug]/page.tsx
+++ /dev/null
@@ -1,19 +0,0 @@
-import React from "react";
-import { technologies } from "./data";
-import TechnologyContent from "./content";
-
-export default async function TechnologyPage({
- params,
-}: {
- params: Promise<{ slug: string }>;
-}) {
- const { slug } = await params;
- return ;
-}
-
-// Generate static params for these dynamic routes
-export async function generateStaticParams() {
- return Object.keys(technologies).map((slug) => ({
- slug,
- }));
-}
diff --git a/apps/web/app/(site)/technologies/layout.tsx b/apps/web/app/(site)/technologies/layout.tsx
deleted file mode 100644
index 1191fef..0000000
--- a/apps/web/app/(site)/technologies/layout.tsx
+++ /dev/null
@@ -1,9 +0,0 @@
-import { LegacyLightSurface } from "@/src/components/LegacyLightSurface";
-
-export default function LegacyLayout({
- children,
-}: {
- children: React.ReactNode;
-}) {
- return {children};
-}
diff --git a/apps/web/app/(site)/websites/layout.tsx b/apps/web/app/(site)/websites/layout.tsx
deleted file mode 100644
index 1191fef..0000000
--- a/apps/web/app/(site)/websites/layout.tsx
+++ /dev/null
@@ -1,9 +0,0 @@
-import { LegacyLightSurface } from "@/src/components/LegacyLightSurface";
-
-export default function LegacyLayout({
- children,
-}: {
- children: React.ReactNode;
-}) {
- return {children};
-}
diff --git a/apps/web/app/(site)/websites/page.tsx b/apps/web/app/(site)/websites/page.tsx
deleted file mode 100644
index f8a1706..0000000
--- a/apps/web/app/(site)/websites/page.tsx
+++ /dev/null
@@ -1,245 +0,0 @@
-"use client";
-
-import { Reveal } from "@/src/components/Reveal";
-import { Section } from "@/src/components/Section";
-import {
- H1,
- H3,
- LeadText,
- BodyText,
- Label,
- MonoLabel,
-} from "@/src/components/Typography";
-import { Button } from "@/src/components/Button";
-import { Marker } from "@/src/components/Marker";
-import { AbstractCircuit, GradientMesh } from "@/src/components/Effects";
-import { GlitchText } from "@/src/components/GlitchText";
-
-export default function WebsitesPage() {
- return (
-
-
-
-
-
-
-
-
- PROFESSIONELLE WEBSITES
-
-
- Ihre Website.
- Komplett sorgenfrei.
-
-
-
-
-
- Kein WordPress-Chaos. Kein Baukasten-Frust. Ich baue Ihnen eine
- maßgeschneiderte Website, mit der Sie{" "}
-
- null Arbeit
- {" "}
- haben.
-
-
-
-
-
-
- {[
- {
- label: "Kein CMS-Zwang",
- desc: "Sie müssen kein System lernen. Ich übernehme alles.",
- },
- {
- label: "Fixpreis",
- desc: "Klare Kosten von Anfang an. Keine versteckten Gebühren.",
- },
- {
- label: "Pfeilschnell",
- desc: "Keine langen Ladezeiten. Kunden bleiben auf der Seite.",
- },
- {
- label: "Sorglos",
- desc: "Hosting, Sicherheit, Backups? Darum kümmere ich mich.",
- },
- ].map((item, i) => (
-
-
- {item.desc}
-
- ))}
-
-
-
-
-
- {/* 02: Performance */}
-
-
-
-
- Niemand wartet gerne.
-
- Ihre Kunden erst recht nicht.
-
-
-
-
-
-
-
- Langsame Websites kosten bares Geld. Wenn Ihre Seite nicht
- sofort lädt, ist der Besucher schon bei der Konkurrenz. Meine
- Websites sind auf maximale Geschwindigkeit optimiert.
-
-
-
-
- {[
- "Sofortiger Seitenaufbau ohne Verzögerung",
- "Automatische Bild-Optimierung für Smartphones",
- "Bessere Google-Platzierung (SEO) durch Top-Speed",
- ].map((item, i) => (
-
-
-
- {item}
-
-
- ))}
-
-
-
-
-
-
- {/* 03: Code-Qualität */}
-
-
-
-
- Handarbeit statt
- Fertigbausatz.
-
-
-
-
-
-
- Vergessen Sie Sicherheitslücken durch veraltete Plugins oder
- Themes, die ständig aktualisiert werden müssen.
-
-
-
-
-
-
-
- Ihre Website wird von Grund auf solide entwickelt. Kein
- unnötiger Ballast, der die Seite verlangsamt oder angreifbar
- macht.
-
-
-
-
-
- Moderne Technologien garantieren, dass Ihre Website auch in
- ein paar Jahren noch perfekt und fehlerfrei läuft.
-
-
-
-
-
-
-
-
- {/* 04: Sorglos Paket */}
-
-
-
-
- Das Prinzip:
- Null Aufwand.
-
-
-
-
-
-
- Sie haben Besseres zu tun, als Bilder zu tauschen oder Updates
- zu installieren.
-
-
-
-
-
-
- Mein Sorglos-Paket deckt alles für ein ganzes Jahr ab. Wenn
- Sie eine Änderung brauchen, schreiben Sie mir einfach eine
- E-Mail. Kein kompliziertes System, keine Schulungen. Ich setze
- es für Sie um.
-
-
-
-
-
- Änderungen & Wartung
-
-
-
-
- 0%
-
-
-
-
-
-
-
-
- {/* 05: CTA */}
- }
- >
-
-
-
-
- Ihre fertige
-
-
- Website.
-
-
-
-
-
-
-
-
- Kein Stress, kein Overhead. Schreiben Sie mir einfach eine
- Nachricht.
-
-
-
-
-
-
-
-
- );
-}
diff --git a/apps/web/app/api/tweet/[id]/route.ts b/apps/web/app/api/tweet/[id]/route.ts
deleted file mode 100644
index a752e12..0000000
--- a/apps/web/app/api/tweet/[id]/route.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { NextResponse } from 'next/server';
-import { getTweet } from 'react-tweet/api';
-
-export async function GET(
- request: Request,
- { params }: { params: Promise<{ id: string }> }
-) {
- const { id } = await params;
-
- try {
- const tweet = await getTweet(id);
-
- if (!tweet) {
- return NextResponse.json({ error: 'Tweet not found' }, { status: 404 });
- }
-
- return NextResponse.json({ data: tweet });
- } catch (error) {
- console.error('Error fetching tweet:', error);
- return NextResponse.json({ error: 'Failed to fetch tweet' }, { status: 500 });
- }
-}
diff --git a/apps/web/app/debug-mdx/route.ts b/apps/web/app/debug-mdx/route.ts
deleted file mode 100644
index 5c9f79e..0000000
--- a/apps/web/app/debug-mdx/route.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { NextResponse, NextRequest } from "next/server";
-import { revalidatePath } from "next/cache";
-import fs from "fs";
-import path from "path";
-
-export async function GET(request: NextRequest) {
- try {
- const searchParams = request.nextUrl.searchParams;
- const pathParam = searchParams.get("path") || "/";
- const typeParam =
- (searchParams.get("type") as "page" | "layout") || "layout";
-
- // Revalidate the requested path (defaults to entire app via layout)
- revalidatePath(pathParam, typeParam);
-
- return NextResponse.json({
- success: true,
- revalidatedPath: pathParam,
- revalidatedType: typeParam,
- message: `Cache revalidated for ${pathParam} (${typeParam})`,
- });
- } catch (err: any) {
- return NextResponse.json({ success: false, error: err.message });
- }
-}
diff --git a/apps/web/content-engine.config.ts b/apps/web/content-engine.config.ts
deleted file mode 100644
index 06991b6..0000000
--- a/apps/web/content-engine.config.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { ComponentDefinition } from '@mintel/content-engine';
-import path from 'path';
-import { componentDefinitions } from './src/content-engine/definitions';
-
-export const config = {
- // Path to documentation files used as context for the AI
- contextDir: path.join(process.cwd(), 'docs'),
-
- // Custom UI components available for injection
- components: componentDefinitions
-};
diff --git a/apps/web/content/blog/analytics-ohne-tracking-dsgvo-konforme-insights-ohne-user-ueberwachung.mdx b/apps/web/content/blog/analytics-ohne-tracking-dsgvo-konforme-insights-ohne-user-ueberwachung.mdx
deleted file mode 100644
index 56337f9..0000000
--- a/apps/web/content/blog/analytics-ohne-tracking-dsgvo-konforme-insights-ohne-user-ueberwachung.mdx
+++ /dev/null
@@ -1,153 +0,0 @@
----
-title: "Analytics ohne Tracking: DSGVO-konforme Insights ohne User-Überwachung"
-thumbnail: "/blog/analytics-ohne-tracking-dsgvo-konforme-insights-ohne-user-ueberwachung.png"
-description: "Erfahren Sie, wie moderne Digital-Architektur präzise Besucherströme misst, ohne die Privatsphäre zu verletzen oder nervige Cookie-Banner zu benötigen."
-date: "2026-02-09"
-tags: ["privacy", "analytics"]
----
-
-
- "Ich brauche Google Analytics, um zu wissen, was meine Nutzer tun." – Diese weit verbreitete Fehlannahme kostet B2B-Unternehmen täglich Vertrauen und massive Datenqualität.
-
-
-
- In meiner täglichen Arbeit als Digital Architect beweise ich das Gegenteil: Maximale geschäftliche Erkenntnis erfordert keine maximale private Überwachung.
-
-
-
- Ich zeige Ihnen, wie wir Erfolg präzise messen, die DSGVO-Konformität systemisch verankern und dabei die Privatsphäre Ihrer Kunden schützen, ohne auf valide Daten zu verzichten.
-
-
-
-
-**TL;DR:** Klassisches Tracking via Google Analytics verliert durch Consent-Ablehnung bis zu 70% der Daten. Privacy-First Analytics arbeitet serverseitig (First-Party), kommt ohne Banner aus und liefert 100% genauere Trends bei maximalem Datenschutz und signifikant besserem PageSpeed.
-
-
Analytics ohne den Beigeschmack der Überwachung
-
-
- Klassische Analytics-Tools funktionieren oft wie ein Trojaner. Sie sammeln riesige Mengen an persönlichen Daten, um daraus Profile zu bilden, die weit über Ihre Website hinausgehen. Dies zwingt Sie rechtlich in die Knie: Sie benötigen komplexe Consent-Management-Plattformen (CMPs) und riskieren dennoch Abmahnungen. Laut einer Untersuchung des HTTP Archive machen Third-Party-Requests einen massiven Teil des Datenaufkommens aus, was die Ladezeit unnötig belastet.
-
-
-
- Das Paradoxon: Die meisten dieser Daten benötigen Sie für Ihre operativen Entscheidungen gar nicht. Sie wollen wissen, welche Inhalte funktionieren, welche Kampagnen konvertieren und wo Nutzer abspringen – nicht, welche anderen Websites Ihre Besucher in ihrer Freizeit besuchen. Studien von Google Developers zeigen zudem, dass Third-Party-JavaScript oft zum Performance-Flaschenhals wird.
-
-
-
-
- graph LR
- A["Besucherstrom"] --> B["Privacy-Proxy"]
- B --> C["Aggregate Metriken"]
- B --> D["Zero PII Data"]
- C --> E["Business Optimierung"]
- D --> F["100% Banner-Frei"]
-
-
-
-
Das Problem der Datenlücke durch Consent-Zwang
-
-
- Die Realität in Europa ist ernüchternd für Marketer, die auf klassische Tools setzen. Eine Studie von Deloitte zeigt, dass europäische Websites Datenverluste zwischen 30% und über 70% allein durch DSGVO-Consent-Anforderungen verzeichnen. Wenn der Nutzer "Ablehnen" klickt, bleibt das Unternehmen blind.
-
-
-
-
-
- Wahre Souveränität bedeutet, Insights zu generieren, ohne sich von der Komplexität eines GA4-Setups abhängig zu machen. Wer [Websites ohne Cookie-Banner](/blog/website-without-cookie-banners) betreibt, signalisiert Professionalität. Zudem heben Studien der Nielsen Norman Group hervor, dass langsame Ladezeiten – oft verursacht durch drittanbieter-lastige Skripte – direkt zu Frustration führen. Besonders kritisch: Laut Nielsen Norman Group sehen Websites einen signifikanten Drop in getrackten Usern, sobald ein Banner implementiert wird, da Nutzer zunehmend skeptisch gegenüber Tracking sind.
-
-
-
-
-
Die Architektur für ethische Insights
-
-
- Ich integriere Analytics direkt in Ihre Plattform-Architektur. Das bedeutet: Keine externen Scripte von US-Servern, was die Performance massiv verbessert. Ein sauberer [systemischer Architektur-Ansatz für die DSGVO](/blog/gdpr-conformity-system-approach) ist hier der Schlüssel.
-
-
-
-
- Cookieless Tracking: Wir erkennen wiederkehrende Nutzer über kurzlebige, anonyme Hashes. Keine Speicherung am Endgerät notwendig.
-
-
- First-Party Data: Alle Daten bleiben in Ihrem Hoheitsbereich (z.B. auf einem [professionellen Hosting](/blog/professional-hosting-operations)).
-
-
- Lightweight Implementation: Statt 100KB Tracking-Ballast nutzen wir Lösungen unter 1KB. Geschwindigkeit trifft auf Erkenntnis.
-
-
-
-
-
-
-
-
- Interne Daten von Google bestätigen, dass striktes Consent-Management die gemeldeten User-Metriken drastisch reduziert. Wer auf [Clean Code](/blog/clean-code-for-business-value) setzt, erkennt schnell: Weniger "Noise" führt zu besseren Signalen.
-
-
-
Der Haken an der Sache: Wo sind die Grenzen?
-
-
- Als Digital Architect ist es meine Pflicht, auch die Grenzen moderner Cookieless-Systeme aufzuzeigen. Während wir die Privatsphäre schützen, müssen wir bei der Langzeit-Kohorten-Analyse Kompromisse eingehen.
-
-
-
-
-
- Google versucht mit dem "Consent Mode" zwar Datenlücken durch Modellierung zu schließen, doch eine vollständige Wiederherstellung der Daten ist technisch nicht möglich. Mein Ansatz verfolgt das Prinzip der [Digital Longevity](/blog/digital-longevity-architecture): Ein System, das stabil und ohne rechtliche Zitterpartie funktioniert.
-
-
-
Der unternehmerische Hebel: Performance ist Umsatz
-
-
- Daten von Deloitte belegen, dass die Verbesserung der Ladezeit die Conversion-Rates signifikant steigert. Jedes gesparte Tracking-Skript zahlt direkt auf diesen ROI ein. Ein stabiles System ist kein Kostenfaktor, sondern ein [ROI-Beschleuniger](/blog/clean-code-for-business-value).
-
-
-
-
-
-
-
-
-
- Wenn Sie auf Ihrer Website kein Banner benötigen, messen Sie 100% Ihres Traffics aggregiert. Es ist die ehrlichere Metrik für Ihre Marketing-Planung. Erfahren Sie hier mehr über die [versteckten Kosten von zu vielen Plugins](/blog/hidden-costs-of-wordpress-plugins), die oft auch Tracking-Balast mitbringen.
-
-
-
-
-
Fazit
-
-
- Messen Sie, was zählt – und schützen Sie, wer zählt. Ein moderner Ansatz macht Datenschutz zu Ihrem Wettbewerbsvorteil statt zum Compliance-Albtraum. Die Kombination aus maximaler Performance, Banner-Freiheit und präzisen Business-Insights ist heute kein "Entweder-oder" mehr. Wer seine Architektur heute auf Privacy-First umstellt, sichert sich die Datenhoheit für das nächste Jahrzehnt und reduziert [technische Altlasten](/blog/slow-loading-costs-customers) nachhaltig.
-
-
-
-
Verliere ich durch Cookieless Analytics wichtige Funktionen?
- Sie verlieren die Möglichkeit, Einzelnutzer über Monate hinweg zu verfolgen. Für die meisten B2B-Unternehmen ist jedoch der Gewinn von 100% sauberen Trend-Daten weitaus wertvoller als ungenaue Einzelprofile.
-
-
Ist Analytics ohne Banner wirklich 100% rechtssicher?
- Ja, sofern keine personenbezogenen Daten (PII) gespeichert werden und die Anonymisierung bereits auf dem Server (First-Party) stattfindet. Dies eliminiert die Notwendigkeit für eine Einwilligung nach TTDSG/DSGVO.
-
-
Wie wirkt sich der Verzicht auf Tracker auf SEO aus?
- Extrem positiv. Durch verbesserte Core Web Vitals (da weniger JavaScript die Main-Thread-Arbeit blockiert) wertet Google die Seite höher ein, was zu besseren Rankings führen kann.
-
\ No newline at end of file
diff --git a/apps/web/content/blog/build-first-digital-architecture.mdx b/apps/web/content/blog/build-first-digital-architecture.mdx
deleted file mode 100644
index 8a941d9..0000000
--- a/apps/web/content/blog/build-first-digital-architecture.mdx
+++ /dev/null
@@ -1,182 +0,0 @@
----
-title: "Build vs. Buy: Warum Build-First die einzige Strategie für B2B-Marktführer ist"
-thumbnail: "/blog/build-first-digital-architecture.png"
-description: "Software-Miete vs. digitales Eigentum: Erfahren Sie, warum Bespoke Software laut Deloitte und McKinsey den ROI maximiert und Ihre Unabhängigkeit im B2B sichert."
-date: "2026-02-05"
-tags: ["architecture", "business", "roi"]
----
-
-
- "Gekauft ist schneller als gebaut." – In der schnelllebigen B2B-Welt ist dieser Satz oft der teuerste Irrtum, den ein Unternehmen begehen kann. Während SaaS-Lösungen an der Oberfläche glänzen, bröckelt darunter oft das strategische Fundament und die Innovationsfähigkeit.
-
-
-
- In meiner Arbeit als Digital Architect sehe ich täglich, wie Standard-SaaS-Lösungen Innovationen im Keim ersticken. Unternehmen bezahlen für Features, die sie nicht brauchen, während ihnen die entscheidenden 5 % für echte Marktdifferenzierung fehlen.
-
-
-
- Ich zeige Ihnen heute, warum Bauen die moderne Form der ökonomischen Effizienz ist, wie Sie technologische Schulden vermeiden und sich durch digitales Eigentum (IP) einen uneinholbaren Wettbewerbsvorteil sichern.
-
-
-
-
TL;DR
-
-
- Asset-Building: Eigene Software ist ein strategischer Firmenwert (IP) und kein reiner Kostenblock.
-
-
- Wachstums-Hebel: Custom-Lösungen erzielen laut Deloitte ein um 15 % höheres Umsatzwachstum.
-
-
- Effizienz: 20–30 % Steigerung der Prozesseffizienz durch Process Mining und Customizing (KPMG).
-
-
- Souveränität: Wer den Code besitzt, kontrolliert Roadmap, Datenhoheit und Skalierbarkeit ohne Drittanbieter-Limits.
-
-
-
-
-
Inhaltsverzeichnis
-
-1. [Die Sackgasse der Generic-Software](#die-sackgasse-der-generic-software)
-2. [Der wirtschaftliche Case von Build-First](#der-wirtschaftliche-case-von-build-first)
-3. [Digitales Eigentum als strategischer Hebel](#digitales-eigentum-als-strategischer-hebel)
-4. [Der Haken an der Sache (Ehrliche Analyse)](#der-haken-an-der-sache)
-5. [FAQ & Fazit](#fazit)
-
-
-
Die Sackgasse der Generic-Software
-
-
- Standard-Software ist darauf ausgelegt, dem kleinsten gemeinsamen Nenner zu gefallen. Man bekommt ein schnelles Resultat, läuft aber sofort gegen eine Wand, wenn man Prozesse wirklich optimieren will. Während die Initialkosten niedrig wirken, steigen die Lizenzkosten bei wachsender Nutzung oft linear an. [Baukasten-Systeme bedrohen Ihre Unabhängigkeit](/blog/builder-systems-threaten-independence), indem sie Sie in ein Korsett aus vorgegebenen Workflows zwängen.
-
-
-
-
-
-
-
- Ihre Wettbewerber nutzen wahrscheinlich exakt die gleiche Software wie Sie. Wo bleibt da der technologische Vorsprung? Deloitte berichtet, dass Organisationen, die maßgeschneiderte Technologielösungen priorisieren, **2,2-mal wahrscheinlicher das durchschnittliche Umsatzwachstum ihrer Branche übertreffen**. Wer nur mietet, bleibt im Mittelfeld.
-
-
-
-
-
Bauen bedeutet heute: Strategisches Kombinieren
-
-
- "Bauen" heißt heute nicht mehr, jedes Rad neu zu erfinden. Es bedeutet [Clean Code](/blog/clean-code-for-business-value) und die Nutzung moderner Architekturen. Wer hier auf [professionelles Hosting](/blog/professional-hosting-operations) setzt, schafft ein stabiles Fundament. Wir nutzen spezialisierte Microservices, um Ihr individuelles System zu komponieren – präzise, schnell und ohne Ballast. Ein maßgeschneidertes Data-Analytics-System kann laut Accenture die Effizienz allein durch datengetriebene Insights um bis zu 25 % steigern.
-
-
-
-
-
- Dabei besitzen Sie den Code und kontrollieren die Datenströme. Das Ergebnis ist eine Lösung, die so flexibel ist wie eine Eigenentwicklung, aber durch moderne Toolchains fast so schnell einsatzbereit wie ein Standardprodukt. Dies sichert Ihnen eine langfristige [Digital Longevity](/blog/digital-longevity-architecture) und schützt vor dem Platform-Lock-in.
-
-
-
Der wirtschaftliche Case von 'Build-First'
-
-
- Die Investition in Individualsoftware wird oft als Risiko wahrgenommen. Die nackten Zahlen der führenden Beratungsgesellschaften zeichnen jedoch ein anderes Bild. Laut McKinsey führt Prozess-Digitalisierung (gegenüber Standard-SaaS) zu einer Reduktion der operativen Kosten um 20-40 %. Deloitte ergänzt, dass Unternehmen mit maßgeschneiderten Lösungen eine um 30 % bessere Kundenbindung erzielen.
-
-
-
-
-
- Maßgeschneiderte Software amortisiert sich oft bereits nach der ersten Skalierungsphase. Ein wesentlicher Grund dafür ist die Reduktion von technischen Reibungsverlusten. [Langsame Ladezeiten kosten Kunden](/blog/slow-loading-costs-customers) – ein Problem, das Individualsoftware durch radikale Performance-Optimierung (z.B. [Google PageSpeed Guide](/blog/google-pagespeed-guide-warum-ladezeit-ihr-wichtigster-b2b-umsatzhebel-ist)) elegant eliminiert.
-
-
-
-
-
-
-
-
-
Digitales Eigentum als strategischer Hebel
-
-
- Wer den Code besitzt, besitzt die Zukunft seines Unternehmens. In Krisenzeiten oder bei strategischen Neuausrichtungen ist technische Unabhängigkeit ein entscheidender Faktor. [Warum Ihre Agentur für kleine Änderungen Wochen braucht](/blog/why-agencies-are-slow), liegt oft am mangelnden Zugriff auf die Kern-Logik gemieteter Systeme oder überladener Strukturen wie [WordPress-Plugins](/blog/hidden-costs-of-wordpress-plugins).
-
-
-
-
-
-
-
- Ich erzeuge Architekturen, die konsequent auf Ownership setzen. Das bedeutet auch: Schutz vor globalen Ausfällen von Drittanbietern und eine drastisch reduzierte Angriffsfläche durch einen [systemischen DSGVO-Ansatz](/blog/gdpr-conformity-system-approach). Deloitte's Research zeigt: Investitionen in maßgeschneiderte digitale Lösungen führen oft bereits im ersten Jahr zu einer 20 %igen Verbesserung der operativen Effizienz.
-
-
-
-
-
Der Haken an der Sache (Ehrliche Analyse)
-
-
- Keine Architektur-Strategie ist ohne Preis. Build-First erfordert Mut und ein höheres initiales Commitment des Managements. Während Gartner bestätigt, dass Process Mining die Kosten bereits im ersten Jahr um 15 % senken kann, ist der initiale Planungsaufwand höher als beim bloßen "Klick-auf-Abonnieren".
-
-
-
-
-
-
-
-
-
-
-
Fazit: Hören Sie auf zu mieten, fangen Sie an zu besitzen
-
-
- Wahrer Reichtum im digitalen Zeitalter entsteht durch Eigentum und technologische Souveränität. Während Ihre Konkurrenz in starren SaaS-Strukturen gefangen ist, bietet Ihnen eine Eigenentwicklung die Freiheit, Ihre Prozesse radikal zu optimieren. Laut Deloitte resultiert die Implementierung individueller IT-Optionen in einer **25 %igen Reduktion der IT-Betriebskosten über drei Jahre**.
-
-
-
- Qualität und Marktführerschaft sind keine Zufallsprodukte, sondern eine bewusste Entscheidung für den Bau eigener Werte. Verwandeln Sie Ihre IT von einem unvermeidbaren Kostenfaktor in einen strategischen Vermögenswert, der Ihr Unternehmen über Jahrzehnte trägt.
-
-
-
-
Wann lohnt sich 'Build' gegenüber 'Buy' finanziell?
-
- Es lohnt sich, wenn Software den Kern Ihrer Wertschöpfung betrifft. Sobald Standardlösungen Ihre Effizienz um >10% deckeln oder die Skalierung die Lizenzgebühren explodieren lässt, ist Build die rentablere Wahl.
-
-
-
Wie wirkt sich Custom Software auf die Marge aus?
-
- Durch die Reduktion operativer Kosten um bis zu 40% (McKinsey) und ein schnelleres "Time-to-Insight" (40% schneller laut Deloitte) verbessert Custom Software direkt das EBITDA und die Wettbewerbsgeschwindigkeit.
-
-
-
Was passiert mit der Wartung bei Eigenentwicklungen?
-
- Moderne Headless-Architekturen sind durch ihre Entkopplung wartungsarm. Im Gegensatz zu WordPress müssen bei einem Custom Stack nicht 50 Plugins gleichzeitig kompatibel gehalten werden, was die Stabilität massiv erhöht.
-
-
\ No newline at end of file
diff --git a/apps/web/content/blog/builder-systems-threaten-independence.mdx b/apps/web/content/blog/builder-systems-threaten-independence.mdx
deleted file mode 100644
index 6d18950..0000000
--- a/apps/web/content/blog/builder-systems-threaten-independence.mdx
+++ /dev/null
@@ -1,168 +0,0 @@
----
-title: "Vendor Lock-In vermeiden: Warum Baukasten-Systeme Ihre Unabhängigkeit bedrohen"
-thumbnail: "/blog/builder-systems-threaten-independence.png"
-description: "Erfahren Sie, wie proprietäre Systeme und SaaS-Baukästen Ihre digitale Souveränität gefährden und warum eine cloud-agnostische Architektur Ihr wertvollstes Business-Asset ist."
-date: "2026-02-08"
-tags: ["architecture", "business"]
----
-
-
- "Wir können nicht wechseln, der Umzug wäre zu teuer und technisch schlicht unmöglich."
-
-
-
- In meiner Arbeit als Digital Architect ist dieser Satz oft der Anfang vom Ende jeder technologischen Innovation. Wenn die Kosten eines Wechsels den Nutzen übersteigen, befinden Sie sich in einer Sackgasse.
-
-
-
- Vendor Lock-In ist die digitale Version einer Geiselnahme. Ich zeige Ihnen, wie wir Systeme bauen, die Ihnen jederzeit die volle Freiheit lassen – technologisch und wirtschaftlich.
-
-
-
Inhaltsverzeichnis
-- [Die unsichtbaren Ketten proprietärer Systeme](#die-unsichtbaren-ketten-proprietärer-systeme)
-- [Der wirtschaftliche Preis der Abhängigkeit](#der-wirtschaftliche-preis-der-abhängigkeit)
-- [Technologische Souveränität als Asset](#technologische-souveränität-als-asset)
-- [Meine Architektur der Ungebundenheit](#meine-architektur-der-ungebundenheit)
-- [Der Haken an der Sache: Die Kosten der Freiheit](#der-haken-an-der-sache-die-kosten-der-freiheit)
-- [Fazit: Freiheit ist eine strategische Wahl](#fazit-freiheit-ist-eine-strategische-wahl)
-
-
Die unsichtbaren Ketten proprietärer Systeme
-
-
- Viele Unternehmen lassen sich von der Bequemlichkeit großer SaaS-Plattformen oder "All-in-One"-Baukästen blenden. Man erhält schnell glänzende Features, gibt aber im Gegenzug die Kontrolle über seine Daten und die Codebasis ab. Oft wird unterschätzt, dass [technische Qualität direkt den Business-Value skaliert](/blog/clean-code-for-business-value).
-
-
-
- Nach zwei bis drei Jahren sind Sie so tief im Ökosystem eines Anbieters verstrickt, dass ein Auszug finanziell ruinös erscheint. Der Anbieter erkennt diese Abhängigkeit – und diktiert fortan die Preise sowie das Tempo Ihrer digitalen Entwicklung. Ich nenne das technologische Erpressbarkeit.
-
-
-
-
-
-
-
-
-
Der wirtschaftliche Preis der Abhängigkeit
-
-
- Lock-In ist kein rein technisches Problem; es ist ein massives finanzielles Risiko. Wer in proprietären "Walled Gardens" baut, zahlt langfristig eine Innovations-Steuer. Oft hängen diese Systeme an veralteten Strukturen, die wie [versteckte Kosten durch Plugins](/blog/hidden-costs-of-wordpress-plugins) das Budget auffressen.
-
-
-
-
-
- Laut Gartner geben Organisationen, die an spezifische Software-Verschreiber gebunden sind, im Schnitt 15-20% mehr für Lizenzierung und Support aus als Unternehmen mit flexiblen Lösungen. Wer hingegen auf [cloud-agnostische Strategien](/blog/no-us-cloud-platforms) setzt, reduziert seine Infrastrukturkosten im ersten Jahr um durchschnittlich 15%.
-
-
-
Technologische Souveränität als Asset
-
-
- Software sollte für Sie arbeiten, nicht umgekehrt. Indem wir auf offene Standards und portable Architekturen setzen, verwandeln wir Code in ein echtes Firmen-Asset (Intellectual Property). Dies ist ein zentraler Pfeiler für die [digitale Langlebigkeit Ihrer Architektur](/blog/digital-longevity-architecture).
-
-
-
-
-
-
-
- Ein cloud-agnostischer Ansatz ermöglicht es Ihnen, den Provider zu wechseln oder das Team zu skalieren, ohne jemals bei Null anfangen zu müssen. Dies ist kein Gimmick, sondern eine unternehmerische Notwendigkeit in einem volatilen Markt.
-
-
-
-
-
Meine Architektur der Ungebundenheit
-
-
- Ich baue keine "Käfige". Mein Fokus liegt auf [Build-First Strategien](/blog/build-first-digital-architecture), die Modularität und Portabilität in den Vordergrund stellen.
-
-
-
-
- Standard-basiertes Engineering: Nutzung von Technologien (HTML, CSS, JS), die weltweit verstanden werden. Keine proprietären "Blackbox"-Module.
-
-
- Daten-Souveränität: Ihre Daten gehören Ihnen. Wir bauen APIs, die Interoperabilität fördern und System-Integrationen um 25% erfolgreicher machen.
-
-
- Containerisierung: Durch Docker und Kubernetes erzielen wir eine bis zu 40% schnellere Deployment-Rate über verschiedene Cloud-Umgebungen hinweg.
-
-
-
-
-
-
-
-
- Diese Unabhängigkeit führt direkt zu einer besseren Performance. Daten des HTTP Archive zeigen, dass Websites, die auf offenen Webstandards basieren, im Schnitt 10% schneller laden als solche, die auf proprietären Frameworks feststecken. Dies ist ein entscheidender [Faktor für Ihre B2B-Umsätze](/blog/google-pagespeed-guide-warum-ladezeit-ihr-wichtigster-b2b-umsatzhebel-ist).
-
-
-
Der Haken an der Sache: Die Kosten der Freiheit
-
-
- Als Digital Architect bin ich Ihnen Transparenz schuldig. Echte Unabhängigkeit kommt nicht zum Nulltarif.
-
-
-
-
-
- Für Unternehmen, die nur eine "Visitenkarte" im Netz brauchen, ist mein Ansatz Overkill. Wenn Ihre Website jedoch ein kritischer Teil Ihrer Wertschöpfungskette ist (Lead-Gen, Recruiting, Produkt-Konfiguration), ist die "Miete" Ihrer Kern-Technologie ein strategischer Fehler.
-
-
-
-
-
Der strategische Hebel für langfristige Rendite
-
-
- Systeme ohne Lock-In altern besser. Sie lassen sich schrittweise modernisieren, statt alle fünf Jahre einen teuren "Relaunch" (Totalabriss) zu benötigen. Das spart Millionen an Opportunitätskosten. Investieren Sie in intelligente Unabhängigkeit.
-
-
-
-
-
-
-
Fazit: Freiheit ist eine strategische Wahl
-
-
- Technologie sollte Ihnen Flügel verleihen, keine Fesseln anlegen. Unternehmen, die auf Multi-Cloud und offene Standards setzen, erreichen laut McKinsey eine 20% höhere Innovationsrate.
-
-
-
- Lassen Sie uns gemeinsam ein System schaffen, das so flexibel ist wie Ihr Business. Werden Sie unersetzbar durch Qualität, nicht durch die Unfähigkeit, zu wechseln. Ihr technologisches Fundament ist kein Kostenfaktor, sondern Ihr wichtigstes Asset.
-
-
-
-
Was ist der größte Vorteil von cloud-agnostischer Architektur?
- Der größte Vorteil ist die Portabilität und Risikominimierung. Sie können Workloads jederzeit zwischen Anbietern verschieben, was die Verhandlungsmacht stärkt und die Business Continuity um 30% verbessert.
-
-
Ab wann lohnt sich der Aufwand gegen Vendor Lock-In?
- Sobald die digitale Plattform ein Kernbestandteil Ihres Geschäftsmodells ist. Bei einer geplanten Nutzungsdauer von über 3 Jahren amortisieren sich die höheren Initialkosten durch wegfallende Lizenzgebühren und höhere Agilität schnell.
-
-
Sind Open-Source-Lösungen nicht unsicherer?
- Im Gegenteil. Durch die Transparenz des Codes können Sicherheitslücken schneller identifiziert und unabhängig von einem einzelnen Anbieter geschlossen werden, was zu einer robusteren Sicherheitsarchitektur führt.
-
\ No newline at end of file
diff --git a/apps/web/content/blog/clean-code-for-business-value.mdx b/apps/web/content/blog/clean-code-for-business-value.mdx
deleted file mode 100644
index a291937..0000000
--- a/apps/web/content/blog/clean-code-for-business-value.mdx
+++ /dev/null
@@ -1,166 +0,0 @@
----
-title: "Der ROI von Clean Code: Warum technische Qualität Ihr Business skaliert"
-thumbnail: "/blog/clean-code-for-business-value.png"
-description: "Software-Engineering als Wertanlage: Wie Clean Code die Wartungskosten um bis zu 80% senkt und die Time-to-Market für neue Features massiv beschleunigt."
-date: "2026-01-30"
-tags: ["development", "business", "software-architecture"]
----
-
-
- Code ist nicht nur eine Anweisung für Maschinen. Er ist das digitale Fundament Ihres Unternehmenswertes und entscheidet über Agilität oder Stillstand.
-
-
-
- In meiner täglichen Praxis als Digital Architect begegne ich oft "historisch gewachsenen" Systemen, die eher einem gordischen Knoten gleichen als einer sauberen Architektur.
-
-
-
- Ich zeige Ihnen heute, warum Clean Code kein akademischer Luxus ist, sondern die härteste Währung für Ihre Zukunftsfähigkeit im Wettbewerb.
-
-
-
-
-
-
-**TL;DR:** Unsauberer Code ("Technical Debt") frisst bis zu 80% Ihres IT-Budgets für reine Wartung. Clean Code reduziert die Debugging-Zeit um 30% und ermöglicht es Teams, 70% ihrer Zeit in echte Innovation statt in Bugfixing zu investieren.
-
-
Die versteckten Kosten von 'Quick-and-Dirty'
-
-
- Softwareentwicklung unter Zeitdruck führt oft zu unsauberen Abkürzungen. Kurzfristig spart das vielleicht Tage, doch langfristig erstickt es jede Innovation. Wenn Entwickler gezwungen sind, auf einem instabilen Fundament zu bauen, entstehen sogenannte technische Schulden.
-
-
-
- Studien des National Institute of Standards and Technology (NIST) zeigen, dass die Kosten für das Beheben von Defekten exponentiell steigen, je länger der Code ohne Refactoring altert. Was heute eine kleine Unsauberkeit ist, kann in zwei Jahren die gesamte Plattform lahmlegen.
-
-
-
-
-
- Ich nenne das technologische Verstopfung. Ihre Entwickler verbringen dann den Großteil ihrer Zeit mit Archäologie in alten Code-Schichten und Bugfixing, statt an Wettbewerbsvorteilen zu arbeiten. Laut DORA-Metriken können Teams mit sauberem Code bis zu 70% ihrer Kapazität für neue Features nutzen, während "unclean" Teams bei 30% stagnieren.
-
-
-
-
-
-
-
-
Wirtschaftliche Hebelkraft durch Code-Qualität
-
-
- Die Entscheidung für Qualität ist eine rein betriebswirtschaftliche. Organisationen geben laut Standish Group ca. 80% ihres Budgets für die Instandhaltung aus. Durch die Reduzierung der Defektdichte – oft um bis zu 40% durch moderne Analyse-Tools – wird Kapital frei, das direkt in das [Build-First Prinzip](/blog/build-first-digital-architecture) fließen kann.
-
-
-
-
-
- Häufig entstehen diese Kosten durch den [Vendor Lock-In in unflexiblen Baukastensystemen](/blog/builder-systems-threaten-independence). Ein sauberer, modularer Ansatz sorgt hingegen für [digitale Langlebigkeit](/blog/digital-longevity-architecture).
-
-
-
-
-
- Wie unterscheidet sich meine Arbeit von Standard-Agentur-Code? Es ist der Übergang von "Basteln" zu echtem Corporate Engineering. Ein gut strukturiertes System "erklärt" sich selbst und macht Sie unabhängig von einzelnen Personen.
-
-
-
-
- Single Responsibility: Jede Komponente hat eine klare Aufgabe. Das verhindert Seiteneffekte und macht Updates sicher.
-
-
- Self-Testing Systems: Automatisierte Tests prüfen jede Änderung. Qualität ist systemimmanent, nicht optional.
-
-
- Domain Driven Design: Die Software spricht die Sprache Ihres Business, nicht die Sprache der Datenbank.
-
-
-
-
-
-
-
-
Der Haken an der Sache: Die Wahrheit über Clean Code
-
-
- Ich bin ehrlich zu Ihnen: Exzellenz braucht am Anfang mehr Zeit. Wer "billig und schnell" bestellt, wird mit Clean Code nicht glücklich – zumindest im ersten Monat.
-
-
-
-
-
Digitale Assets vs. Verbindlichkeiten
-
-
- Software sollte in Ihrer Bilanz als Vermögenswert auftauchen, nicht als laufende Verbindlichkeit. Wenn Ihre Website bei jedem Update zerbricht, haben Sie ein Problem in der [Update-Stabilität](/blog/why-websites-break-after-updates).
-
-
-
-
-
- Sauberer Code reduziert die Onboarding-Zeit neuer Entwickler massiv. Google konnte nachweisen, dass konsistente Styles und klare Strukturen die Innovationszyklen beschleunigen, da weniger Zeit mit "Code-Rätselraten" verschwendet wird.
-
-
-
-
-
-
-
Fazit: Qualität gewinnt immer
-
-
- Es gibt keine Abkürzung zu exzellenter Software. Wer beim Fundament spart, zahlt später die Zeche durch langsame Prozesse und [ineffiziente IT-Infrastrukturen](/blog/slow-loading-costs-customers).
-
-
-
- Lassen wir den Ballast von unsauberem Code hinter uns. Ich baue Ihnen eine Architektur, die nicht nur heute funktioniert, sondern durch ihre Eleganz und Klarheit auch in zehn Jahren noch ein stabiles Asset für Ihr Unternehmen ist.
-
-
-
-
-
-
Was ist der größte Vorteil von Clean Code für Geschäftsführer?
- Der größte Vorteil ist die Reduzierung der Gesamtkosten (TCO). Da Wartung bis zu 80% des Budgets frisst, setzt sauberer Code massives Kapital für neue Innovationen statt für Reparaturen frei.
-
-
Dauert die Entwicklung mit Clean Code länger?
- Initial ja, etwa 15-20% mehr Zeitaufwand in der Konzeption. Dieser Aufwand amortisiert sich jedoch bereits nach wenigen Monaten durch eine 30% schnellere Fehlerbehebung und reibungslose Updates.
-
-
Kann man bestehenden 'Dirty Code' retten?
- Ja, durch schrittweises Refactoring und die Einführung automatisierter Tests. Es ist ein Prozess der Wertsteigerung, der technisch verschuldete Systeme wieder in liquide digitale Assets verwandelt.
-
\ No newline at end of file
diff --git a/apps/web/content/blog/crm-synchronization-headless.mdx b/apps/web/content/blog/crm-synchronization-headless.mdx
deleted file mode 100644
index 381b6aa..0000000
--- a/apps/web/content/blog/crm-synchronization-headless.mdx
+++ /dev/null
@@ -1,192 +0,0 @@
----
-title: "B2B CRM-Integration: Wie automatisierte Datenflüsse 12% Ihres Umsatzes retten"
-thumbnail: "/blog/crm-synchronization-headless.png"
-description: "Vom Kontaktformular direkt in den Sales-Funnel: Wie Sie manuelle Daten-Silos auflösen, die Sales-Produktivität um 14,5% steigern und menschliche Fehler eliminieren."
-date: "2026-01-31"
-tags: ["crm", "architecture", "automation"]
----
-
-
- Die wertvollsten Daten Ihres Unternehmens liegen oft in Silos versteckt. Ihre Website sammelt Leads, aber Ihr CRM "weiß" nichts davon – oder erst nach mühsamer, manueller Übertragung durch Ihre Sales-Teams.
-
-
-
- Dieser "Media Break" ist nicht nur ineffizient, sondern ein massives finanzielles Risiko. Ich beende das Zeitalter der Daten-Inseln durch hochperformante, architektonische CRM-Synchronisation.
-
-
-
- In diesem Guide zeige ich Ihnen, wie eine nahtlose Integration Ihre Marketing-Effizienz skaliert, die Fehlerquote eliminiert und Ihre Response-Time auf ein marktführendes Niveau hebt.
-
-
-
-
Inhaltsverzeichnis
- 1. [Das Problem der manuellen Daten-Brücke](#das-problem-der-manuellen-daten-brücke)
- 2. [Der ökonomische Impact von Datenqualität](#der-ökonomische-impact-von-datenqualität)
- 3. [Speed-to-Lead als Wettbewerbsvorteil](#speed-to-lead-als-wettbewerbsvorteil)
- 4. [Der Haken an der Sache: Komplexität vs. Stabilität](#der-haken-an-der-sache)
- 5. [Architektonische Hebel für Ihre Daten-Souveränität](#meine-hebel-für-ihre-daten-souveränität)
- 6. [Fazit](#fazit-lassen-sie-ihre-daten-fließen)
-
-
-
Das Problem der manuellen Daten-Brücke
-
-
- Viele Unternehmen nutzen Kontaktformulare, die lediglich eine formatierte E-Mail versenden. Ein Mitarbeiter muss diese lesen und die Daten händisch in Salesforce, HubSpot oder Microsoft Dynamics übertragen. Dieser Prozess ist ein Relikt aus dem letzten Jahrzehnt.
-
-
-
- Laut einer Studie von PricewaterhouseCoopers können Fehler bei der manuellen Dateneingabe Unternehmen bis zu **12% ihres Jahresumsatzes** kosten. Jedes falsch abgetippte Feld und jeder vergessene Lead ist bares Geld, das verloren geht.
-
-
-
-
-
-
-
- Echte Professionalität bedeutet: Die Software erledigt die Arbeit im Hintergrund, während sich Ihre Sales-Experten auf den Abschluss konzentrieren. [Technische Qualität skaliert Ihr Business](/blog/clean-code-for-business-value) weit über das Maß hinaus, das händische Prozesse je erreichen könnten.
-
-
-
Der ökonomische Impact von Datenqualität
-
-
- Datenqualität ist kein "Nice-to-have" für die IT-Abteilung, sondern eine kritische Business-Kennzahl. Gartner schätzt, dass schlechte Datenqualität Organisationen durchschnittlich **15 Millionen Dollar pro Jahr** kostet.
-
-
-
-
-
-
-
Speed-to-Lead als Wettbewerbsvorteil
-
-
- In der B2B-Welt zählt jede Sekunde. Research der Aberdeen Group zeigt, dass Best-in-Class Unternehmen zu **53% häufiger** ihre Lead-Management-Prozesse automatisiert haben. Dies führt zu drastisch schnelleren Reaktionszeiten.
-
-
-
-
-sequenceDiagram
- participant B as Besucher
- participant W as Website (Headless)
- participant V as Validation Layer
- participant C as CRM (HubSpot/SF)
- participant S as Sales Team
- B->>W: Formular absenden
- W->>V: Daten-Validierung & Bereinigung
- V->>C: API-Push (Realtime)
- C->>S: Slack/E-Mail Alert (< 5 Min)
-
-
-
-
- B2B-Einkäufer, die innerhalb von 5 Minuten eine Antwort erhalten, treten mit einer **21-fach höheren Wahrscheinlichkeit** in den Verkaufsprozess ein. Eine verzögerte Antwort aufgrund manueller Prozesse ist oft gleichbedeutend mit einem verlorenen Lead an den Wettbewerber.
-
-
-
CRM-Integration als Investition mit hohem ROI
-
-
- Die Implementierung einer sauberen Schnittstelle rechnet sich schneller, als die meisten Entscheider vermuten. Nucleus Research fand heraus, dass jeder in ein CRM investierte Dollar durchschnittlich **8,71 $ zurückgibt**. Das funktioniert jedoch nur, wenn das System gefüttert wird – und zwar automatisch.
-
-
-
-
-
Der Haken an der Sache: Kosten vs. Risiko
-
-
- Ich bin kein Freund davon, Technologie zu beschönigen. Eine professionelle CRM-Integration ist komplexer als die Installation eines Standard-Plugins. Hier ist die ungeschminkte Wahrheit:
-
-
-
-
-
-
- Hohe Initialkosten: Eine saubere API-Architektur erfordert Senior-Engineering.
-
-
- Wartungsaufwand bei API-Wechsel: Ändert das CRM seine Schnittstelle, muss der Code angepasst werden.
-
-
- Langfristige Unabhängigkeit: Sie besitzen die Datenbrücke und unterliegen keinem [Vendor Lock-In durch Baukasten-Systeme](/blog/builder-systems-threaten-independence).
-
-
-
-
Meine Hebel für Ihre Daten-Souveränität
-
-
- Integration bedeutet für mich mehr als nur das Verbinden von Endpunkten. Es geht um die Schaffung einer Single Source of Truth. Meine Architektur basiert auf drei Säulen:
-
-
-
-
-
- Oft wird vergessen, dass die [Wahl des Hostings](/blog/professional-hosting-operations) und die Architektur der Website direkt die Zuverlässigkeit dieser Schnittstellen beeinflussen. Instabile Systeme führen zu [hohen versteckten Kosten](/blog/hidden-costs-of-wordpress-plugins).
-
-
-
-
-
-
-
Fazit: Lassen Sie Ihre Daten fließen
-
-
- Technologie sollte Reibung eliminieren, nicht neue Hürden schaffen. Unternehmen, die heute noch Daten manuell einpflegen, verbrennen nicht nur Zeit, sondern riskieren ihre Marktposition durch langsame Response-Times und fehlerhafte Datensätze.
-
-
-
- Gartner schätzt, dass **40% aller CRM-Fehlschläge** auf Prozessprobleme oder menschliches Versagen zurückzuführen sind. Eine automatisierte Integration ist die wirksamste Versicherung gegen dieses Risiko. [Vermeiden Sie technische Altlasten](/blog/slow-loading-costs-customers) und machen Sie Ihre Website zu einem integralen Bestandteil Ihres Sales-Motors.
-
-
-
-
-
-
Wie lange dauert die Integration eines CRMs?
-
- Eine Standard-Anbindung per API ist innerhalb von 1-2 Wochen stabil implementiert. Komplexe Workflows mit individuellem Data Enrichment erfordern je nach Anforderung 3-4 Wochen Entwicklungszeit.
-
-
-
Welche CRMs werden unterstützt?
-
- Jedes System mit einer modernen REST- oder GraphQL-API kann angebunden werden. Dazu gehören Salesforce, HubSpot, Pipedrive, Microsoft Dynamics 365 und spezialisierte Branchenlösungen.
-
-
-
Ist die Integration DSGVO-konform?
-
- Ja, absolut. Die Datenübertragung erfolgt verschlüsselt, und es werden nur die Daten verarbeitet, für die eine explizite Nutzerwahrnehmung (z.B. Checkbox im Formular) vorliegt.
-
-
\ No newline at end of file
diff --git a/apps/web/content/blog/digital-longevity-architecture.mdx b/apps/web/content/blog/digital-longevity-architecture.mdx
deleted file mode 100644
index 46c0003..0000000
--- a/apps/web/content/blog/digital-longevity-architecture.mdx
+++ /dev/null
@@ -1,164 +0,0 @@
----
-title: "Digital Longevity: B2B-Software-Architektur für das nächste Jahrzehnt"
-thumbnail: "/blog/digital-longevity-architecture.png"
-description: "Software ohne Verfallsdatum: Erfahren Sie, wie nachhaltige Architektur technische Schulden minimiert und langfristige digitale Assets statt Liability schafft."
-date: "2026-02-02"
-tags: ["architecture", "longevity", "strategy"]
----
-
-
- In einer Branche, die von Quartalszahlen und kurzlebigen Hypes getrieben wird, gilt Software oft schon nach 24 Monaten als veraltet.
-
-
- Ich betrachte diese technologische Kurzatmigkeit als massive Verschwendung von Kapital, Energie und Fokus. Wahre Qualität bemisst sich nicht am Tag des Launchs, sondern daran, wie ein System altert.
-
-
- Ich zeige Ihnen, wie wir digitale Werte für Jahrzehnte schaffen – durch vorausschauende Architektur, die technische Schulden proaktiv verhindert statt sie nur zu verwalten.
-
-
-
-**TL;DR:**
-Die durchschnittliche App überlebt kaum 14-24 Monate. Durch modulare Headless-Architekturen, den Verzicht auf kurzlebige Frameworks und [Clean Code](/blog/clean-code-for-business-value) verwandeln wir IT von einem Kostenfaktor in ein langlebiges digitales Asset mit einer Lebensdauer von 10+ Jahren.
-
-
-
-
Inhaltsverzeichnis
-1. [Gegen die Wegwerf-Mentalität im Code](#gegen-die-wegwerf-mentalität-im-code)
-2. [Der ökonomische Case für Langlebigkeit](#der-ökonomische-case-für-langlebigkeit)
-3. [Prinzipien für ewige Systeme](#meine-prinzipien-für-ewige-systeme)
-4. [Der Haken an der Sache (Ehrliche Analyse)](#der-haken-an-der-sache)
-5. [Fazit & FAQ](#fazit-werte-schaffen-die-bleiben)
-
-
-
Gegen die Wegwerf-Mentalität im Code
-
-
- Viele Agenturen bauen "Schönwetter-Lösungen". Man setzt auf proprietäre Blackboxes oder überladene Frameworks, die nach kurzer Zeit nicht mehr unterstützt werden. Das Ergebnis ist eine kostspielige Spirale aus [technischen Altlasten](/blog/slow-loading-costs-customers) und erzwungenen Relaunchs alle drei Jahre. Studien zeigen, dass Organisationen bis zu **75% ihres IT-Budgets** allein dafür aufwenden, "das Licht am Laufen zu halten" – primär bedingt durch veraltete Infrastruktur.
-
-
-
-
-
-
-
- Ich nenne das geplante Obsoleszenz der Software. Während B2B-Lösungen eigentlich für 5-10 Jahre ausgelegt sein sollten, werden viele mobile Apps bereits nach 12-14 Monaten grundlegend neu geschrieben. Im B2B-Sektor ist diese Kurzlebigkeit ein strategisches Risiko. Mein Ansatz ist das Gegenteil: Ich baue Systeme, die durch ihre innere Ordnung bestechen. Guter Code ist wie eine solide Immobilie – er braucht Pflege, aber keine Abrissbirne.
-
-
-
-
-
Der ökonomische Case für Langlebigkeit
-
-
- Unternehmen investieren oft Unsummen in glänzende Oberflächen, während das Fundament bröckelt. Dabei zeigen Analysen, dass Unternehmen zwischen **60% und 80% ihres IT-Budgets** für die reine Maintenance von Legacy-Systemen binden. Dieser "Legacy-Tax" entzieht Ressourcen für echte Innovationen.
-
-
-
-
-
- Durch den Einsatz eines [Clean Code Fokus](/blog/clean-code-for-business-value) verwandeln wir Software von einer Verbindlichkeit (Liability) in ein echtes digitales Asset. Wenn die Architektur stimmt, sinken die Wartungskosten massiv, während die Agilität steigt. Software, die auf [unabhängigen Architekturen](/blog/builder-systems-threaten-independence) basiert, lässt sich modular erweitern, ohne das Gesamtsystem zu gefährden.
-
-
-
-
-
Die Ästhetik der Zeitlosigkeit
-
-
- Langlebigkeit hat eine technische und eine visuelle Komponente. Ich vermeide "modische" Spielereien, die morgen schon peinlich wirken könnten. Ein industrieller, klarer Look altert langsamer als jede verspielte Grafik. Wir setzen auf [Responsive Excellence](/blog/responsive-design-high-fidelity), die auch auf Endgeräten der nächsten Generation souverän wirkt.
-
-
-
Meine Prinzipien für ewige Systeme
-
-
- Wie baut man Software, die nicht veraltet? Durch die kompromisslose Auswahl der Fundamente und die Abkehr von [Abhängigkeiten durch Baukasten-Systeme](/blog/builder-systems-threaten-independence). Ein zentraler Baustein ist die Reduzierung der Komplexität: Je weniger bewegliche Teile (Plugins, Drittanbieter-Frameworks), desto geringer die Angriffsfläche für technischen Zerfall.
-
-
-
-
- Industrie-Standards statt Hypes: Einsatz von Technologien mit globalem Rückhalt (React, Node.js, Go). Keine Experimente mit Nischen-Tools ohne Langzeit-Sicherheit.
-
-
- Strict Separation of Concerns: Saubere Trennung von Design, Daten und Logik (Headless). So lassen sich Einzelteile austauschen, ohne das Gesamtsystem zu gefährden.
-
-
- Automatisierte Evolution: Kontinuierliche Refactoring-Zyklen. Laut Google Developers erfordern mobile Apps alle 1-2 Monate Updates, um mit Betriebssystemen kompatibel zu bleiben – eine solide Architektur macht dies zum Kinderspiel.
-
-
-
-
-
-
-
-
-
-
-
-
-
Der Haken an der Sache (Devil's Advocate)
-
- Langlebige Architektur ist kein Free Lunch. Warum baut dann nicht jede Agentur so? Weil es Disziplin und Zeit kostet, die im kurzfristigen Projektgeschäft oft nicht gewollt ist.
-
-
-
- Höhere Initialkosten: Eine saubere Architektur erfordert initial ca. 20-30% mehr Architektur-Planung als eine "Plug-and-Play"-Solution.
-
-
- Keine schnellen Quick-Fixes: "Einfach mal kurz ein Plugin installieren" gibt es bei mir nicht, da dies die Integrität gefährdet.
-
-
- Hoher Anspruch an den Kunden: Sie müssen Software als strategisches Asset begreifen, nicht als einmaliges Projekt-Häkchen.
-
-
-
-
-
-
-
Rendite durch technologische Beständigkeit
-
-
- Wahrer ROI entsteht erst über die Zeit. Wer nicht alle 36 Monate neu baut, hat mehr Kapital für echtes Wachstum zur Verfügung. Large Organizations geben jährlich Millionen für die Instandhaltung von Legacy-Systemen aus – Geld, das in Neuentwicklungen besser aufgehoben wäre.
-
-
-
-
-
-
-
- Investieren Sie in Substanz, nicht in flüchtige Effekte. In einem Markt, in dem über die Hälfte des Budgets in die reine Erhaltung fließt, ist technologische Stabilität ein [entscheidender Wettbewerbsvorteil](/blog/build-first-digital-architecture). Unser Fokus auf [professionelles Hosting](/blog/professional-hosting-operations) unterstützt diesen langlebigen Ansatz.
-
-
-
Fazit: Werte schaffen, die bleiben
-
-
- Digitale Exzellenz misst sich am Erfolg von morgen. Wenn Sie technologische Stabilität als Teil Ihres unternehmerischen Vermächtnisses begreifen, ist eine "Build-First" Strategie alternativlos. Lassen wir gemeinsam ein System gießen, das die Zeit überdauert. Qualität ist Beständigkeit. Ihr Erfolg verdient eine Architektur ohne Verfallsdatum, die mit Ihrem Business wächst, statt es durch technische Schulden zu bremsen.
-
-
-
-
Warum halten moderne Plattformen oft nur 2-3 Jahre?
- Meist liegt es an einer zu engen Kopplung an instabile Plugins und kurzlebige Trends. Laut Gartner werden Enterprise-Apps oft alle 7-10 Jahre ersetzt, da sie unter der Last ihrer eigenen Komplexität kollabieren.
-
-
Rechnet sich die höhere Initialinvestition wirklich?
- Absolut. Da Unternehmen durchschnittlich 50-60% ihres IT-Budgets für Legacy-Wartung verschwenden, amortisiert sich eine saubere Architektur oft schon nach dem ersten nicht notwendigen Relaunch-Zyklus.
-
-
Wie oft muss langlebige Software aktualisiert werden?
- Langlebigkeit bedeutet nicht Stillstand. Updates alle 1-2 Monate sind laut Android/Google Developers essenziell, um mit OS-Innovationen Schritt zu halten – eine gute Architektur macht diese Updates jedoch risikoarm.
-
\ No newline at end of file
diff --git a/apps/web/content/blog/fixed-price-digital-projects.mdx b/apps/web/content/blog/fixed-price-digital-projects.mdx
deleted file mode 100644
index ce4bb48..0000000
--- a/apps/web/content/blog/fixed-price-digital-projects.mdx
+++ /dev/null
@@ -1,165 +0,0 @@
----
-title: "Der strategische Festpreis: Warum Budgetsicherheit die Software-Qualität maximiert"
-thumbnail: "/blog/fixed-price-digital-projects.png"
-description: "Keine Angst vor uferlosen Stundenabrechnungen. Erfahren Sie, warum ein Festpreis-Modell mit Risiko-Buffern der fairste Weg zu High-End Software-Lösungen ist."
-date: "2026-02-04"
-tags: ["management", "business"]
----
-
-
- Sicherheitsdenken ist tief in der menschlichen Natur verwurzelt – besonders wenn es um sechsstellige Projektbudgets im B2B-Sektor geht.
-
-
- Niemand möchte am Ende eines Quartals feststellen, dass das digitale Fundament doppelt so viel kostet wie geplant, während die Timeline stagniert.
-
-
- In meiner Arbeit als Digital Architect baue ich Sicherheit durch Transparenz und zeige Ihnen, warum ein intelligenter Festpreis der fairste Weg zu exzellenten Ergebnissen ist.
-
-
-
-
Inhaltsverzeichnis
-
-
-
-
Die Falle der unendlichen Stunden
-
-
- In der klassischen Softwareentwicklung ist die Abrechnung nach Stunden (Time & Material) der Industriestandard. Doch bei genauer Betrachtung setzt dieses Modell einen völlig falschen Anreiz: Je ineffizienter ein Entwickler arbeitet oder je schlechter die Architektur geplant wurde, desto mehr verdient die Agentur.
-
-
-
- Effizienz wird ökonomisch bestraft, während [technische Altlasten](/blog/slow-loading-costs-customers) und langsame Prozesse den Umsatz des Dienstleisters steigern. Ich hingegen habe mein gesamtes Business auf Geschwindigkeit und architektonische Klarheit optimiert.
-
-
-
-
-
- Mit einem strategischen Festpreis drehen wir den Spieß um: Mein Anreiz ist Ihre schnellstmögliche Zufriedenheit. Da das Budget fixiert ist, liegt es in meinem eigenen Interesse, eine so saubere Architektur zu bauen, dass keine Bugs oder langwierigen Korrekturschleifen mein Zeitbudget fressen. So entsteht echte Partnerschaft statt eines Interessenkonflikts.
-
-
-
-
-
-
-
Zahlen, Daten, Fakten: Warum Risiko-Management kein Zufall ist
-
-
- Die Realität in der IT ist oft ernüchternd. Viele Projekte scheitern nicht an der Technik, sondern an mangelhafter finanzieller und zeitlicher Planung. Ein strategischer Festpreis erfordert eine Reife im Risikomanagement, die viele Organisationen vermissen lassen.
-
-
-
-
-
- Studien von PricewaterhouseCoopers (PwC) zeigen deutlich: Projekte, die formale Risikomanagement-Prozesse inklusive Puffer nutzen, erreichen ihre Ziele 2,5-mal häufiger. Ein Festpreis ist für mich kein Glücksspiel, sondern das Ergebnis einer präzisen mathematischen Kalkulation.
-
-
-
-
-
-graph LR
- A["Festpreis"] --> B["Effizienz-Zwang"]
- B --> C["Hohe Code-Qualität"]
- C --> D["Schneller Release"]
- D --> E["Hoher ROI"]
- style A fill:#4ade80,stroke:#333
- style E fill:#4ade80,stroke:#333
-
-
-
-
-
Planung als Fundament digitaler Exzellenz
-
-
- Ein Festpreis kann nur funktionieren, wenn die Vision klar definiert ist. Deshalb investiere ich zu Beginn massiv Zeit in die Analyse und das "Blueprint-Design". Wer hier spart, zahlt später doppelt – eine Lektion, die ich auch in meinem Artikel über den [ROI von Clean Code](/blog/clean-code-for-business-value) ausführlich beschreibe.
-
-
-
- Das ist digitales Engineering mit norddeutscher Klarheit. Sie bezahlen nicht für mein Ausprobieren oder für das Training von Junioren, sondern für die punktgenaue Umsetzung jahrelanger Erfahrung.
-
-
-
-
-
-
-
Der Haken an der Sache: Die Grenzen des Festpreises
-
-
- Um als Digital Architect glaubwürdig zu bleiben, muss ich offen sagen: Ein Festpreis ist kein Allheilmittel. Er erfordert Disziplin auf beiden Seiten.
-
-
-
-
-
- Laut PMI (Project Management Institute) neigen Festpreis-Projekte stärker zu Scope Creep (48%) als T&M-Projekte. Daher ist eine [saubere Architektur-Strategie](/blog/digital-longevity-architecture) essenziell, um Erweiterungen später modular und kosteneffizient zu ermöglichen, ohne das initiale Festpreis-Fundament zu sprengen.
-
-
-
Ihr Investment in psychologische Sicherheit
-
-
- Ein Festpreis befreit den Kopf. Statt bei jedem Meeting die virtuelle Uhr ticken zu hören, konzentrieren wir uns auf das Wesentliche: Ihren Markterfolg. Das schafft eine Atmosphäre von Kreativität und technologischem Mut.
-
-
-
- Integrierte Risiko-Abdeckung bedeutet für Sie: Unvorhergesehene technische Hürden sind mein Problem, nicht Ihres. Deloitte berichtet, dass Organisationen mit starken PM-Praktiken 28-mal weniger Geld verschwenden. Mein Festpreis-Modell ist der operative Arm dieser Erkenntnis.
-
-
-
-
-
-
-
Fazit: Klarheit ist kein Luxus
-
-
- Lassen wir das Rätselraten bei der Preisgestaltung hinter uns. Das "Time & Material"-Modell dient oft als Schutzschild für planlose Agenturen. Mein Festpreis-Modell hingegen ist ein Qualitätsversprechen. Es zwingt mich zu technischer Exzellenz und bietet Ihnen die finanzielle Planbarkeit, die Sie für die Skalierung Ihres Unternehmens benötigen.
-
-
-
- Pünktlich. Präzise. Zum vereinbarten Preis. Das ist kein Marketing-Slogan, sondern die Basis für [langfristige digitale Unabhängigkeit](/blog/builder-systems-threaten-independence).
-
-
-
-
Warum ist ein Festpreis oft teurer als ein initialer Schätzpreis nach Stunden?
-
- Ein Festpreis enthält einen Risiko-Buffer, der Unvorhersehbares abdeckt. Ein Schätzpreis nach Stunden wirkt anfangs günstiger, endet laut McKinsey aber oft 45% über dem Budget, da keine Kostendeckelung existiert.
-
-
-
Wie gehen wir mit Änderungen während des Projekts um?
-
- Kleinere Anpassungen sind im Rahmen der Kulanz oft enthalten. Major Changes werden über Change Requests fair neu bewertet, sodass die Integrität des ursprünglichen Budgets geschützt bleibt.
-
-
-
Eignet sich ein Festpreis für agile Softwareentwicklung?
-
- Ja, durch das Modell des "Agilen Festpreises". Hierbei fixieren wir das Budget und die Qualität, bleiben aber flexibel bei der Priorisierung der Features innerhalb des vereinbarten Rahmens.
-
-
\ No newline at end of file
diff --git a/apps/web/content/blog/gdpr-conformity-system-approach.mdx b/apps/web/content/blog/gdpr-conformity-system-approach.mdx
deleted file mode 100644
index 5d64ac2..0000000
--- a/apps/web/content/blog/gdpr-conformity-system-approach.mdx
+++ /dev/null
@@ -1,189 +0,0 @@
----
-title: "DSGVO-Konformität: Warum Privacy by Design der ultimative B2B-Wettbewerbsvorteil ist"
-thumbnail: "/blog/gdpr-conformity-system-approach.png"
-description: "Vergessen Sie Cookie-Banner. Echte DSGVO-Konformität entsteht durch Privacy by Design und saubere Systemarchitektur. Ein Leitfaden für Digital Architects."
-date: "2026-02-10"
-tags: ["legal", "gdpr", "architecture"]
----
-
-
- DSGVO-Konformität wird im B2B-Mittelstand oft als lästiges bürokratisches Hindernis oder notwendiges Übel wahrgenommen, das man mit nervigen Cookie-Bannern "löst".
-
-
- In meiner Arbeit als Digital Architect sehe ich sie jedoch als das ultimative Qualitätsmerkmal für sauberes Engineering. Ein System, das Daten systemisch schützt, ist ein gesundes, effizientes und hochperformantes System.
-
-
- Ich zeige Ihnen, warum wir Datenschutz architektonisch lösen müssen, statt ihn nur mit rechtlichen Pflastern zu flicken – und wie dies direkt auf Ihren ROI einzahlt.
-
-
-
-
Inhaltsverzeichnis
- - [TL;DR: Compliance als Architektur-Feature](#tldr)
- - [Gegen das Abmahnrisiko – mit Systemarchitektur](#systemarchitektur)
- - [Der wirtschaftliche Case: ROI von Privacy](#roi-privacy)
- - [Privacy by Infrastructure: Der technische Hebel](#infrastructure)
- - [Der Haken an der Sache: Die Wahrheit über radikale Minimierung](#haken)
- - [Fazit: Souveränität durch saubere Technik](#fazit)
-
-
-
TL;DR: Compliance als Architektur-Feature
-
-
- Privacy by Design: Datenschutz ist kein Banner, sondern ein technisches Fundament.
-
-
- Risikominimierung: Wer weniger Daten erhebt, reduziert die Angriffsfläche und Haftung massiv.
-
-
- Wirtschaftlichkeit: Investitionen in Privacy steigern den ROI um den Faktor 1,8.
-
-
-
-
Gegen das Abmahnrisiko – mit Systemarchitektur
-
- Die meisten Unternehmen versuchen, die Anforderungen der DSGVO durch seitenlange Dokumente und nachträglich installierte Consent-Werkzeuge zu lösen. Das ist so, als würde man ein brennendes Haus mit einer neuen Versicherungspolice löschen wollen. Es schafft eine Schein-Sicherheit, bekämpft aber nicht die Ursache des Risikos.
-
-
- Datenschutz muss bereits in der DNA des Codes verankert sein. Wenn ein System von vornherein keine unnötigen Daten sammelt, verschwinden die Einfallstore für rechtliche Probleme von selbst. Wahre Compliance ist nicht rechtlich dokumentiert, sondern technisch erzwungen.
-
-
-
-
-
-
-
- Ein [verantwortungsbewusstes Hosting](/blog/professional-hosting-operations) und eine [saubere Architektur](/blog/digital-longevity-architecture) sorgen dafür, dass Daten erst gar nicht in unsichere Drittstaaten abfließen.
-
-
-
Der wirtschaftliche Case: ROI von Privacy
-
- Wussten Sie, dass unsaubere Datensparsamkeit ein messbares finanzielles Risiko darstellt? Daten, die Sie nicht besitzen, können nicht gestohlen werden. Eine Studie des Ponemon Institute verdeutlicht die Tragweite:
-
-
-
-
-
- Doch es geht nicht nur um Risikovermeidung. Laut Ciscos Data Privacy Benchmark Study sahen Organisationen einen 1,8-fach höheren ROI aus ihren Privacy-Investitionen, wenn sie diese von Anfang an in ihre Prozesse integrierten.
-
-
-
-
-
-
-
Mein Prinzip: Privacy by Infrastructure
-
- Ich betrachte Datenschutz nicht als Text im Footer, sondern als Eigenschaft der Infrastruktur. In einem [Build-First Ansatz](/blog/build-first-digital-architecture) eliminieren wir riskante Abhängigkeiten wie Google Fonts oder Tracking-Pixel von Drittanbietern direkt auf Code-Ebene.
-
-
-
-
-
-
-
- Um dies zu erreichen, setze ich auf drei Säulen:
-
-
-
-
-
Compliance jenseits des Cookie-Popups
-
- Ein [verzichtbarer Cookie-Banner](/blog/website-without-cookie-banners) ist oft ein Zeichen für exzellente Technik. Wer keine nicht-essenziellen Cookies setzt, muss den Nutzer nicht belästigen. Das führt zu einer besseren User Experience und höheren Conversion-Rates.
-
-
-
-
-
Der Haken an der Sache: Die Wahrheit über radikale Minimierung
-
- Es wäre unredlich zu behaupten, dass dieser Ansatz keine Nachteile hat. Privacy by Design erfordert Disziplin und oft den Verzicht auf komfortable, aber datenhungrige "Out-of-the-box"-Lösungen.
-
-
-
-
-
-
- Höherer Planungsaufwand: Man muss sich im Vorfeld genau überlegen, welche Daten wirklich gebraucht werden.
-
-
- Eingeschränktes Ad-Tracking: Wer auf invasive Tracker verzichtet, muss intelligentere, [anonyme Analytics-Modelle](/blog/analytics-ohne-tracking-dsgvo-konforme-insights-ohne-user-ueberwachung) nutzen.
-
-
-
-
Fazit: Souveränität durch saubere Technik
-
- Echte DSGVO-Konformität ist kein Zustand, den man einmal erreicht, sondern ein Prozess, der tief in der Software-Architektur verankert sein muss. Während 96% der Unternehmen zwar "Programme" haben, fühlten sich laut Deloitte nur 30% wirklich auf einen Data Breach vorbereitet.
-
-
- Schaffen wir die Angst vor rechtlichen Fehltritten ab. Ich baue Ihnen ein System, das durch seine innere Ordnung besticht und den Schutz technisch garantiert. Seriosität ist im B2B kein Zufall, sondern planbares Engineering.
-
-
-
-
-
Was ist der Unterschied zwischen Privacy by Design und Privacy by Default?
-
- Privacy by Design bedeutet, den Datenschutz bereits in der Entwicklungsphase eines Systems technisch zu integrieren. Privacy by Default stellt sicher, dass die Werkseinstellungen eines Dienstes immer die datenschutzfreundlichsten sind.
-
-
-
Warum reicht ein Cookie-Banner allein nicht aus?
-
- Ein Banner ist nur ein Interface-Element für die Einwilligung; es verhindert nicht automatisch den technischen Abfluss von Daten im Hintergrund, wie z.B. Log-Files oder IP-Leaks durch CDN-Anbieter. Wahre Compliance muss auf Server-Ebene greifen.
-
-
-
Wie wirkt sich Privacy by Design auf die Website-Performance aus?
-
- Positiv. Da weniger externe Skripte (Tracker, Fonts, Social Plugins) geladen werden, sinkt die Ladezeit signifikant, was wiederum die Core Web Vitals und das Google-Ranking verbessert.
-
-
-
\ No newline at end of file
diff --git a/apps/web/content/blog/google-pagespeed-guide-warum-ladezeit-ihr-wichtigster-b2b-umsatzhebel-ist.mdx b/apps/web/content/blog/google-pagespeed-guide-warum-ladezeit-ihr-wichtigster-b2b-umsatzhebel-ist.mdx
deleted file mode 100644
index 313f007..0000000
--- a/apps/web/content/blog/google-pagespeed-guide-warum-ladezeit-ihr-wichtigster-b2b-umsatzhebel-ist.mdx
+++ /dev/null
@@ -1,216 +0,0 @@
----
-title: "Google PageSpeed Guide: Warum Ladezeit Ihr wichtigster B2B-Umsatzhebel ist"
-thumbnail: "/blog/der-google-pagespeed-guide-warum-ladezeit-ihr-wichtigster-umsatzhebel-ist.png"
-description: "Millisekunden entscheiden im B2B über Erfolg oder Absprung. Erfahren Sie, wie Core Web Vitals Ihre Conversion-Rate und SEO-Rankings massiv beeinflussen."
-date: "2026-02-15"
-tags: ["performance", "seo", "conversion-optimization"]
----
-
-
- Unternehmen investieren oft Unsummen in glänzende Oberflächen, während das technische Fundament einer digitalen Ruine gleicht. Wenn Ihre Website bei Google PageSpeed scheitert, verlieren Sie Kunden – bevor diese Ihre Botschaft überhaupt wahrnehmen können.
-
-
-
- In der digitalen Ökonomie ist Performance kein „Nice-to-have“, sondern die Basis jeder Customer Journey. Akamai fand heraus, dass 53 % der mobilen Website-Besucher eine Seite verlassen, die länger als drei Sekunden zum Laden benötigt.
-
-
-
-
-**TL;DR:** Website-Geschwindigkeit ist ein kritischer Ranking-Faktor und der stärkste Hebel für Conversions. Während Page-Load-Zeiten von 1s auf 3s die Bounce-Rate um 32 % erhöhen, steigert jede 0,1s Verbesserung die Conversion um bis zu 8,4 %. Moderne Architekturen wie Static Site Generation sind der Schlüssel zur Performance-Exzellenz.
-
-
Der unsichtbare Umsatz-Verschleiß
-
-
- Stellen Sie sich vor, Sie eröffnen ein Luxus-Geschäft in der besten Lage, aber die Eingangstür klemmt massiv. Kunden müssen 10 Sekunden lang drücken, um einzutreten. Genau das passiert täglich auf B2B-Websites, deren technische Altlasten die Nutzererfahrung ersticken. [Langsame Ladezeiten](/blog/slow-loading-costs-customers) sind heute der Hauptgrund für hohe Absprungraten und sinkende Sichtbarkeit. 47 % der Nutzer erwarten laut Kissmetrics, dass eine Webseite in zwei Sekunden oder weniger lädt.
-
-
-
-
-
- Millisekunden sind im digitalen Zeitalter die härteste Währung. Daten von Google zeigen: Steigt die Ladezeit von einer auf drei Sekunden, erhöht sich die Wahrscheinlichkeit eines Absprungs um 32 %. Es ist ein gnadenloser Zusammenhang: Je länger der Browser wartet, desto geringer die Wahrscheinlichkeit eines profitablen Abschlusses. Geht die Ladezeit sogar auf sechs Sekunden hoch, steigt die Bounce-Wahrscheinlichkeit laut Google Developers sogar um dramatische 106 %.
-
-
-
-
-
- Ich betrachte Performance nicht als isolierte IT-Kennzahl, sondern als ökonomischen Hebel. Ein [professionelles Hosting](/blog/professional-hosting-operations) und eine saubere Architektur sind die Mindestanforderung. Websites, die in einer Sekunde laden, haben eine signifikant höhere Conversion-Rate als langsamere Instanzen. Eine Studie von Portent untermauert dies: Die Conversion-Rate sinkt im Schnitt um 4,42 % mit jeder zusätzlichen Sekunde Ladezeit. Shopzilla berichtete sogar von einem Umsatzplus von 7-12 %, nachdem sie die Ladezeit von 6 auf 1,2 Sekunden reduzierten.
-
-
-
Core Web Vitals: Die neuen Spielregeln von Google
-
-
- Google hat bestätigt, dass Core Web Vitals als Ranking-Signale für Suchergebnisse genutzt werden. Wer hier rote Zahlen schreibt, wird vom Algorithmus abgestraft. Webseiten, die den Schwellenwert „Gut“ in allen Kategorien erreichen, verzeichnen laut Deloitte eine deutlich höhere Interaktion. Dennoch zeigt das HTTP Archive, dass ein signifikanter Prozentsatz der Websites die empfohlenen Grenzwerte weiterhin massiv verfehlt.
-
-
-
-
-
- Dabei fokussiert sich das Framework auf drei wesentliche Säulen der User Experience, für die Google im PageSpeed Insights Tool spezifische Optimierungsvorschläge liefert:
-
-
-
-
- Largest Contentful Paint (LCP): Ladegeschwindigkeit des Hauptinhalts (Ziel: unter 2,5s).
-
-
- Interaction to Next Paint (INP): Die neue Metrik für Interaktivität (Ziel: unter 200ms).
-
-
- Cumulative Layout Shift (CLS): Verhindert visuelle Instabilität (Ziel: unter 0,1).
-
-
-
-
Warum klassische CMS-Lösungen scheitern
-
-
- Die Ursache für mangelhafte Performance liegt oft in „All-in-One“-Lösungen. [Die versteckten Kosten von WordPress-Plugins](/blog/hidden-costs-of-wordpress-plugins) offenbaren sich spätestens beim ersten Audit. Jedes zusätzliche Plugin erhöht potenziell die Latenz. Nutzer verlassen laut Nielsen Norman Group Webseiten, die langsam oder unresponsiv reagieren, extrem schnell. Jede Sekunde Verzögerung kostet bares Geld.
-
-
-
-
-
-
-
- Jedes Byte muss durch das Nadelöhr der mobilen Verbindung. Wer hier auf [Standard-Templates setzt](/blog/why-no-templates-matter), sabotiert seinen Erfolg. Oft ersticken [Baukasten-Systeme Ihre Unabhängigkeit](/blog/builder-systems-threaten-independence) durch unnötigen Code-Overhead. Walmart konnte zeigen, dass jede Sekunde Ladezeit-Optimierung die Conversions um 2 % steigert.
-
-
-
-
-graph TD
- A["Anfrage Browser"] --> B["Server Rechenlast"]
- B --> C["DB Abfragen"]
- C --> D["HTML Generierung"]
- D --> E["Browser Rendering"]
- E -- "Hohe Latenz" --> F["Nutzer verlässt Seite"]
-
-
-
-
Meine Architektur der Geschwindigkeit
-
-
- Ich verfolge einen [Build-First Ansatz](/blog/build-first-digital-architecture). Statt die Seite erst mühsam zusammenzubauen, wenn der Kunde sie anfragt, liefere ich fertig optimierte statische Ressourcen aus einem globalen Edge-Netzwerk. Dies minimiert die Time to First Byte (TTFB) radikal, oft auf unter 50ms.
-
-
-
-
-
- Das Resultat ist Skalierbarkeit durch Design. Die Antwortzeit bleibt konstant niedrig, egal ob 10 oder 10.000 Nutzer gleichzeitig zugreifen. Dies ist ein entscheidender Wettbewerbsvorteil, da viele B2B-Wettbewerber noch immer erhebliche Defizite aufweisen. Eine [Wartungsfreie Architektur](/blog/maintenance-for-headless-systems) sorgt zudem dafür, dass diese Performance über Jahre stabil bleibt, ohne dass Plugins das System schleichend verlangsamen.
-
-
-
Die drei Säulen der Umsetzung
-
-
-
-
Der Haken an der Sache: Devil's Advocate
-
-
- Ehrlichkeit gehört zu einer profunden Architektur-Beratung. Eine High-End-Performance-Lösung ist kein "Plug-and-Play" und erfordert Investitionen in Expertise statt in billige Massenware.
-
-
-
-
-
-
- Technisches Setup: Der Build-Prozess erfordert modernes DevOps-Know-how statt simpler Klick-Interfaces.
-
-
- Digital Asset: Im Gegensatz zur "Miete" eines Baukastens erschaffen Sie wertbringendes Eigentum (Intellectual Property).
-
-
-
-
-
-
-
-
Der wirtschaftliche Case
-
-
- B2B-Unternehmen verlieren laut Google massiv Conversions pro zusätzlicher Sekunde Ladezeit. Wenn Sie Budget in Marketing investieren, aber Leads durch technische Altlasten verlieren, verbrennen Sie Kapital. [Clean Code](/blog/clean-code-for-business-value) ist hier kein Selbstzweck, sondern eine ökonomische Notwendigkeit für den Return on Ad Spend (ROAS).
-
-
-
-
-
-
-
- Mein System fungiert als ROI-Beschleuniger für Ihren gesamten digitalen Auftritt. Warum viele Agenturen bei diesem Thema scheitern und stattdessen langsame Monolithen verkaufen, erkläre ich im Detail in meinem Artikel [Warum Ihre Agentur für kleine Änderungen Wochen braucht](/blog/why-agencies-are-slow).
-
-
-
-
-
-
-
Fazit: Respekt vor der Zeit Ihrer Nutzer
-
-
- Geschwindigkeit ist letztlich Ausdruck von Wertschätzung. Sie signalisieren Ihrem Kunden: „Ich respektiere deine Zeit.“ Ein technisch überlegenes System ist im B2B-Sektor heute kein Bonus mehr, sondern die Eintrittskarte in den Markt. Jede Millisekunde, die Sie einsparen, ist eine direkte Investition in Ihre Conversion-Rate und Ihre Sichtbarkeit in der Suche.
-
-
-
- Lassen Sie uns Ihre Website in eine hochpräzise Wachstums-Maschine verwandeln, die nicht nur hochwertig aussieht, sondern auf Knopfdruck liefert. Qualität zahlt sich aus – messbar in Sekunden und in Euro.
-
-
-
-
-
-
Warum ist mein PageSpeed-Score mobil oft deutlich schlechter als auf dem Desktop?
-
- Mobile Geräte haben begrenzte Rechenleistung und oft instabile Funkverbindungen. Eine optimierte Architektur reduziert JavaScript-Last (INP) radikal, um diese Beschränkungen auszugleichen.
-
-
-
Reicht ein Caching-Plugin für WordPress nicht aus?
-
- Caching kurapiert nur Symptome, löst aber nicht das Problem von zu viel Code-Ballast. Für echte Spitzenwerte ist eine schlanke, vom CMS entkoppelte Architektur notwendig.
-
-
-
Wie schnell muss eine B2B-Seite wirklich laden?
-
- Der Goldstandard liegt unter 2 Sekunden. Ab 3 Sekunden steigt die Bounce-Rate laut Google massiv um 32 %, was direkte Auswirkungen auf Ihren Umsatz hat.
-
-
\ No newline at end of file
diff --git a/apps/web/content/blog/green-it-sustainable-web.mdx b/apps/web/content/blog/green-it-sustainable-web.mdx
deleted file mode 100644
index f7668cd..0000000
--- a/apps/web/content/blog/green-it-sustainable-web.mdx
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: "Green IT & Digitale Effizienz: Warum nachhaltiger Code profitabler ist"
-thumbnail: "/blog/green-it-sustainable-web.png"
-description: "Nachhaltigkeit als Rendite-Hebel im B2B: Erfahren Sie, wie schlanke Software-Architekturen CO2 senken, Serverlast reduzieren und Ihre Conversion-Rate maximieren."
-date: "2026-02-03"
-tags: ["sustainability", "performance", "digital-architecture"]
----
-
-
- Wussten Sie, dass das Internet für etwa 3,7 % der globalen Treibhausgasemissionen verantwortlich ist? Das ist mehr als der gesamte weltweite Flugverkehr. In einer digitalen Welt, in der Rechenzentren laut IEA bis zu 3 % des weltweiten Stromverbrauchs beanspruchen, wird Effizienz zur moralischen und ökonomischen Pflicht.
-
-
-
- In meiner Rolle als Digital Architect betrachte ich Nachhaltigkeit nicht als bloßes „Greenwashing-Label“, sondern als das finale Stadium technischer Exzellenz. Ein effizientes System ist von Natur aus ein grünes System, das massiv Betriebskosten einspart.
-
-
-
- Schlanke Architekturen sparen nicht nur CO2, sondern massives Budget. Ich zeige Ihnen, warum ökologische Verantwortung und ökonomische Profitabilität im B2B-Sektor durch technologische Disziplin untrennbar miteinander verwoben sind.
-
-
-
-
-**TL;DR:** Nachhaltige IT-Architektur reduziert durch Minimierung von Datenübertragungen und CPU-Zyklen sowohl den ökologischen Fußabdruck als auch die Betriebskosten. Studien belegen, dass schnellere Ladezeiten direkt mit höheren Conversions korrelieren. Wer heute in effizienten Code investiert, baut ein wertstabiles digitales Asset auf.
-
-
Der unsichtbare ökologische Fußabdruck von schlechtem Code
-
-
- Jedes unnötige Kilobyte, das durch das Netz geschickt wird, frisst elektrische Energie – im Rechenzentrum, in den Übertragungsstrecken und schließlich am Endgerät des Nutzers. Laut Google Developers können optimierte Bilder die Dateigröße um 20–80 % reduzieren, ohne nennenswerte Qualitätsverluste zu verursachen, was die CO2-Emissionen beim Datentransfer unmittelbar senkt.
-
-
-
- Viele moderne Websites leiden an „digitaler Adipositas“. Sie schleppen Megabytes an Altlasten mit sich herum, was zu heißgelaufenen Prozessoren führt. [Langsame Ladezeiten](/blog/slow-loading-costs-customers) sind hierbei oft nur das Symptom einer tieferliegenden Ineffizienz, die laut Akamai dazu führt, dass 47 % der Konsumenten erwarten, dass eine Seite in weniger als zwei Sekunden lädt.
-
-
-
-
-
-
-
- Google-Untersuchungen zeigen: Wenn die Ladezeit von einer auf drei Sekunden steigt, springen 32 % mehr Nutzer ab. Wir senken durch optimierten Code die CPU-Zyklen und damit direkt den Energiebedarf. Lean-Architekturen wie Single-Page Applications (SPAs) reduzieren den Datentransfer pro Sitzung sogar um bis zu 60 %.
-
-
-
-
-
-
-
Effizienz als ökonomischer Hebel
-
-
- Nachhaltigkeit in der IT ist kein Verzicht, sondern ein extremer Performance-Boost für Ihr Business. Eine Studie der Nielsen Norman Group schätzt, dass optimierte Performance die Conversion-Raten um 27 % verbessern kann. Höhere Effizienz führt zu geringerem Energieverbrauch pro Transaktion.
-
-
-
-
-
- Wenn Sie auf [Business-Value durch Clean Code](/blog/clean-code-for-business-value) setzen, reduzieren Sie die technologische Schuld. Während Standard-Agenturen oft zu überladenen Baukästen greifen, die Ihre [Unabhängigkeit bedrohen](/blog/builder-systems-threaten-independence), nutzt mein Engineering-Ansatz hochperformante Lösungen, die laut Deloitte die CO2-Emissionen der Website um 29 % senken können.
-
-
-
-
-
Vergleich: Nachhaltige vs. Verschwenderische Architektur
-
-
-
-
Drei Säulen einer nachhaltigen Infrastruktur
-
-
- Als Architekt implementiere ich Systeme, die [Digital Longevity](/blog/digital-longevity-architecture) verkörpern. Das bedeutet, Software so zu bauen, dass sie über Jahre ohne Performance-Verlust besteht, anstatt nach jedem Update instabil zu werden.
-
-
-
-
-
-
- Static-First Strategie: Statische Seiten benötigen keine serverseitige Berechnung bei jedem Aufruf, was Energie spart.
-
-
- CDN-Nutzung: Reduziert die Distanz der Datenpakete und senkt die Latenz sowie den Energieverbrauch um ca. 10–20 %.
-
-
- Green Hosting: Betrieb auf Infrastruktur, die nachweislich mit 100 % erneuerbaren Energien betrieben wird.
-
-
-
-
-
-
-
-
Der Haken an der Sache (Devil's Advocate)
-
-
- Warum baut dann nicht jeder so? Die Wahrheit ist schlicht: Echte Effizienz erfordert initial mehr Gehirnschmalz. Ein Standard-System „zusammenzuklicken“ geht schneller, produziert aber langfristig technische Altlasten.
-
-
-
-
- Höhere Design-Komplexität: Jedes Feature muss auf seine energetische und performante Notwendigkeit geprüft werden.
-
-
- Vermeintlicher Mehraufwand: Die Entwicklung von Individualsoftware ist in der Konzeptionsphase intensiver als fertige Templates.
-
-
-
-
- Wer jedoch Software als strategisches [digitales Asset](/blog/digital-longevity-architecture) betrachtet, erkennt, dass die niedrigeren Betriebskosten und die überlegene Conversion-Rate diesen Initialaufwand bei weitem übertreffen.
-
-
-
-
-
Fokus auf Core Web Vitals
-
-
- Google hat klargestellt: Ein schlechter Lade-Score kostet Sichtbarkeit. Da 53 % der mobilen Nutzer eine Seite verlassen, wenn sie länger als drei Sekunden lädt, ist Performance-Optimierung die ehrlichste Form des Marketings.
-
-
-
-
-
Fazit: Weniger ist mehr Zukunft
-
-
- Green IT ist keine Wohltätigkeitsveranstaltung, sondern technologische Disziplin. Jedes gesparte Byte ist ein Gewinn für Ihre Bilanz und das Klima. Indem wir unnötigen Ballast abwerfen, schaffen wir digitale Erlebnisse, die schneller, sicherer und nachhaltiger sind.
-
-
-
- In einer Welt, in der Energieeffizienz zur überlebenswichtigen Währung wird, ist schlanker Code Ihr wertvollstes Asset. Durch die konsequente Vermeidung von [versteckten Kosten durch Plugins](/blog/hidden-costs-of-wordpress-plugins) sichern Sie sich einen unfairen Wettbewerbsvorteil.
-
-
-
-
Ist nachhaltige Software wirklich spürbar schneller?
-
- Ja. Da Nachhaltigkeit auf der Reduktion von Daten und Rechenoperationen basiert, resultiert dies direkt in minimalen Ladezeiten (TTFB) und einer flüssigeren User Experience.
-
-
-
Amortisieren sich die Kosten für effiziente Programmierung?
-
- Definitiv. Durch geringere Absprungraten (Bounce Rate) und deutlich reduzierte Hosting-Kosten amortisiert sich der Fokus auf Clean Code meist innerhalb der ersten 12 Monate.
-
-
-
Wie wirkt sich Green IT auf mein Google Ranking aus?
-
- Direkt. Google nutzt die Core Web Vitals als Ranking-Faktor. Effiziente Seiten laden schneller und werden somit in den Suchergebnissen bevorzugt behandelt.
-
-
\ No newline at end of file
diff --git a/apps/web/content/blog/hidden-costs-of-wordpress-plugins.mdx b/apps/web/content/blog/hidden-costs-of-wordpress-plugins.mdx
deleted file mode 100644
index b4ba969..0000000
--- a/apps/web/content/blog/hidden-costs-of-wordpress-plugins.mdx
+++ /dev/null
@@ -1,151 +0,0 @@
----
-title: "Die versteckten Kosten von WordPress-Plugins: Performance-Killer & Sicherheitsrisiko"
-thumbnail: "/blog/hidden-costs-of-wordpress-plugins.png"
-description: "Warum Plugin-Bloat Ihre B2B-Website verlangsamt und gefährdet. Erfahren Sie, wie eine saubere Architektur die Wartungskosten senkt und den ROI steigert."
-date: "2026-02-12"
-tags: ["wordpress", "performance", "security", "digital-architecture"]
----
-
-
- In der Welt von WordPress werden Plugins oft als die ultimative Abkürzung zum Erfolg verkauft. Ein Klick, ein Feature – so einfach, oder?
-
-
- In meiner täglichen Praxis als Digital Architect sehe ich jedoch das exakte Gegenteil: Sie sind eine teure Umleitung in eine technische Sackgasse, die sowohl die Performance als auch die Sicherheit Ihrer Plattform untergräbt.
-
-
- Die vermeintlich "schnelle Lösung" ist am Ende oft die teuerste Entscheidung Ihrer digitalen Strategie, da sie technische Schulden anhäuft, die später mit Zinseszins zurückgezahlt werden müssen.
-
-
-
TL;DR: Warum weniger meist mehr ist
-
-
- Sicherheit: Ca. 98% der WordPress-Vulnerabilitäten hängen direkt mit Plugins zusammen.
-
-
- Performance: Jedes Plugin erhöht HTTP-Requests und JavaScript-Execution-Time (Google Developers).
-
-
- Wartungskosten: "Kostenlose" Plugins verursachen hohe laufende Kosten durch Update-Risiken und Inkompatibilitäten.
-
-
-
-
-
-
-
-
Die „Frankenstein-Architektur“ der Plugins
-
- Die Versuchung ist menschlich: Ein neues Feature wird benötigt, und der Plugin-Store verspricht die sofortige Lösung. Doch was Sie wirklich tun, ist fremden, oft ungeprüften Code ungefiltert in Ihr geschäftskritisches System zu lassen. Ich sehe regelmäßig Instanzen, die unter der Last von 40+ Plugins förmlich zermalmt werden.
-
-
- Jedes Plugin verfolgt eine eigene Logik und kämpft mit anderen Komponenten um knappe Ressourcen. Es entsteht eine instabile „Frankenstein-Architektur“, bei der niemand mehr genau sagen kann, welches Skript an welcher Stelle die Ladezeit in die Höhe treibt. Daten von [HTTP Archive](https://httparchive.org) zeigen konsistent eine Korrelation zwischen der Anzahl der JS-Dateien (oft durch Plugins verursacht) und signifikant längeren Ladezeiten.
-
-
-
-
-
-
-
- Sie geben die Kontrolle über Ihre Plattform ab und hängen von der Roadmap Dritter ab. Dies führt oft zu einem [Vendor Lock-In](/blog/builder-systems-threaten-independence), der Ihre technologische Unabhängigkeit bedroht. Wenn ein Entwickler das Interesse verliert oder das Plugin nicht rechtzeitig an PHP-Updates anpasst, steht Ihr gesamtes Business-Fundament auf wackeligen Beinen.
-
-
-
-
- Sicherheit ist kein Plugin, das man installiert, sondern ein Prozess. Dennoch verlassen sich viele Unternehmen auf Security-Plugins, während sie gleichzeitig dutzende Einfallstore durch veraltete Erweiterungen offenlassen.
-
-
-
-
-
- Die Zahlen sind alarmierend: Sicherheitsanalysen von WPScan schätzen, dass rund 98% der WordPress-Vulnerabilitäten im Zusammenhang mit Plugins stehen. Ein einziger kritischer Fehler in einem weit verbreiteten Tool kann ausreichen, um zehntausende Corporate-Websites gleichzeitig zu gefährden. Oft sind es [langsame Ladezeiten und technische Altlasten](/blog/slow-loading-costs-customers), die erst durch solche Sicherheits-Audits ans Licht kommen.
-
-
-
-
-
Performance-Erosion: Der schleichende Umsatzkiller
-
- Schlecht programmierte Plugins erhöhen die Anzahl der Datenbankabfragen massiv. Jede zusätzliche Abfrage belastet die Time to First Byte (TTFB). Google Search Central betont immer wieder, dass schlanker Code und weniger externe Requests direkt mit besseren Rankings korrelieren.
-
-
-
-
-
- Wenn Ihre Seite langsam lädt, verlieren Sie Kunden, bevor diese Ihr Angebot überhaupt sehen. In einer Welt, in der eine Sekunde Verzögerung die Conversion-Rate um bis zu 7% senken kann (Nielsen Norman Group), ist Plugin-Bloat ein ökonomisches Risiko. Hier hilft oft nur ein radikaler [Google PageSpeed Guide](/blog/google-pagespeed-guide-warum-ladezeit-ihr-wichtigster-b2b-umsatzhebel-ist), um die Hebel wieder umzulegen.
-
-
-
-
-
Der "Haken" an der Sache (Devil's Advocate)
-
- Natürlich hat der Verzicht auf Plugins auch seinen Preis. Es ist wichtig, hier transparent zu sein:
-
-
-
-
-
- Maßgeschneiderter Code erfordert am Anfang mehr Zeit für Konzeption und Entwicklung. Wenn Sie nur schnell einen Blog für ein Wochenendprojekt brauchen, ist WordPress mit Plugins unschlagbar. Wenn Sie jedoch eine skalierbare B2B-Plattform aufbauen, ist der "billige" Weg am Ende durch Wartung und Ausfälle meist teurer.
-
-
-
-
-
Mein Weg: Präziser Code statt Blackbox-Plugins
-
- Anstatt ein tonnenschweres Plugin für eine einfache Funktion zu installieren, entwickle ich diese Funktion direkt innerhalb einer modernen Architektur – oft [Headless oder mit statischer Generierung](/blog/maintenance-for-headless-systems).
-
-
- Das Ergebnis ist ein System, das exakt das tut, was Sie brauchen – und kein Byte mehr. Kein Ballast, kein Sicherheitsrisiko, keine Abhängigkeit. Ich baue keine digitalen Kartenhäuser, sondern echte digitale Assets, die für Profis arbeiten. Dies steigert nicht nur die Performance, sondern zahlt direkt auf den [ROI von Clean Code](/blog/clean-code-for-business-value) ein.
-
-
-
Fazit: Investieren Sie in Ihr Fundament
-
- Plugins sind wie billige Anbauwände: Sie wirken im Katalog gut, aber nach dem ersten Umzug wackeln sie. Für ein seriöses B2B-Unternehmen sollte die Website kein Bastelprojekt sein, sondern ein hochpräzises Werkzeug.
-
-
- Lassen Sie uns gemeinsam eine Plattform schaffen, die Ihr Business auch in fünf Jahren noch zuverlässig trägt. Qualität ist keine Kostenstelle, sondern die einzige Abkürzung, die wirklich funktioniert.
-
-
-
-
Warum machen viele Agenturen dennoch alles mit Plugins?
- Es ist für Agenturen profitabler und erfordert weniger tiefgreifendes technisches Know-how. Zudem generieren die ständigen Updates und daraus resultierenden Fehler regelmäßige Wartungsumsätze.
-
-
Gibt es "gute" Plugins?
- Ja, es gibt etablierte Industry-Standards (z. B. für SEO oder Formulare), die jedoch extrem gezielt und sparsam eingesetzt werden müssen. Eine professionelle Architektur minimiert diese auf ein absolutes Minimum.
-
-
Wie erkenne ich, ob meine Seite zu viele Plugins hat?
- Ein Blick in die Core Web Vitals und die Anzahl der geladenen JS/CSS-Dateien gibt ersten Aufschluss. Wenn einfache Inhaltsänderungen zu Systemfehlern führen, ist dies ein deutliches Warnsignal für Plugin-Konflikte.
-
\ No newline at end of file
diff --git a/apps/web/content/blog/maintenance-for-headless-systems.mdx b/apps/web/content/blog/maintenance-for-headless-systems.mdx
deleted file mode 100644
index 926eca8..0000000
--- a/apps/web/content/blog/maintenance-for-headless-systems.mdx
+++ /dev/null
@@ -1,186 +0,0 @@
----
-title: "Wartungsfrei durch Verzicht: Warum 'No-CMS' die überlegene B2B-Architektur ist"
-thumbnail: "/blog/maintenance-for-headless-systems.png"
-description: "Sicherheit und Geschwindigkeit durch architektonische Reduktion: Warum Git-basierte Workflows klassische CMS-Backends in Performance und ROI schlagen."
-date: "2026-02-01"
-tags: ["maintenance", "architecture"]
----
-
-
-Klassische CMS-Systeme sind oft technische Schulden im Gewand einer Nutzeroberfläche. Durch den Wechsel zu Git-basierten "No-CMS" Architekturen eliminieren Unternehmen Sicherheitsrisiken, senken Hostingkosten um bis zu 90% und steigern die Performance massiv.
-
-
-
- Ein Content Management System (CMS) wird oft als Befreiung verkauft. In der Realität ist es für viele Unternehmen der Anfang einer teuren, wartungsintensiven Abhängigkeit.
-
-
- In meiner Praxis beobachte ich regelmäßig, wie B2B-Akteure hunderte Stunden in die Pflege von Systemen investieren, die sie eigentlich entlasten sollten, während die [technische Qualität](/blog/clean-code-for-business-value) auf der Strecke bleibt.
-
-
- Ich zeige Ihnen, warum Content-Management ohne Ballast der wahre Hebel für Geschwindigkeit, Sicherheit und digitalen Fokus ist.
-
-
-
-
-
Der CMS-Wartungs-Albtraum: Ein systemisches Risiko
-
-
- Klassische CMS-Lösungen wie WordPress oder TYPO3 sind komplexe "Software-Monster". Sie basieren auf Datenbanken und Server-Side-Scripting, was sie zu einem primären Ziel für Angriffe macht. Statistiken zeigen, dass WordPress-Plugins für einen signifikanten Prozentsatz aller Website-Schwachstellen verantwortlich sind [Source: Wordfence].
-
-
-
-
-
-
-
-
- Diese Systeme müssen permanent aktualisiert werden. Werden Patches vernachlässigt, steigt das Risiko einer Exploitation exponentiell an [Source: Sucuri]. Diese [versteckten Kosten von Plugins](/blog/hidden-costs-of-wordpress-plugins) fressen Budget, ohne einen einzigen Cent echten Mehrwert für Ihr Business zu generieren. Ich nenne das technische Sisyphusarbeit.
-
-
-
-
-
-
-
Performance als ökonomischer Hebel
-
-
- Jede Sekunde Ladezeit entscheidet im B2B-Sektor über Abbruch oder Anfrage. Während traditionelle CMS bei jedem Aufruf die Datenbank abfragen müssen, liefern Git-basierte Architekturen (Jamstack) fertige statische Dateien über CDNs aus. Das Ergebnis ist eine bis zu 10-fach schnellere Ladezeit im Vergleich zu WordPress [Source: GTmetrix].
-
-
-
-
-
- Diese Geschwindigkeit ist kein Selbstzweck. Wie ich in meinem [Google PageSpeed Guide](/blog/google-pagespeed-guide-warum-ladezeit-ihr-wichtigster-b2b-umsatzhebel-ist) detailliert beschreibe, korreliert die Performance direkt mit Ihren Google-Rankings und der Nutzerzufriedenheit.
-
-
-
-
-
-
-
Content as Code: Die Architektur der digitalen Marktführer
-
-
- Anstatt sich mit unübersichtlichen Admin-Backends und [langsamen Agentur-Zyklen](/blog/why-agencies-are-slow) herumzuschlagen, integrieren wir Inhalte direkt in einen versionierten Workflow.
-
-
-
-
-
- Keine Datenbanken, die korrumpieren können. Kein Backend, das per Brute-Force gehackt werden kann. Analysen zeigen, dass statische Webseiten die Zeit für Sicherheits-Patching um schätzungsweise 60 % reduzieren [Source: OWASP]. Das ist Sicherheit durch Simplizität.
-
-
-
Warum "Kein CMS" die beste CMS-Strategie ist
-
-
- Ein Git-basiertes Setup bietet handfeste wirtschaftliche Vorteile gegenüber der "Software-Miete" klassischer Systeme. Es verwandelt Ihre Website von einer technischen Verbindlichkeit in ein [echtes digitales Asset](/blog/digital-longevity-architecture).
-
-
-
-
- 90 % Kostenersparnis beim Hosting: Durch CDN-basierte Auslieferung ohne teure Server-Infrastruktur [Source: Netlify].
-
-
- 50 % weniger Deployment-Fehler: Git-basierte Workflows minimieren menschliche Fehler im Vergleich zu Live-Edits im CMS-Backend [Source: CircleCI].
-
-
- Zukunftssicherheit: Inhalte liegen in portablen Formaten (Markdown/JSON) vor, statt in proprietären Datenbanken gefangen zu sein ([Vendor Lock-in vermeiden](/blog/builder-systems-threaten-independence)).
-
-
-
-
-
-
-
-
Der strategische Case: Fokus auf Ihr Kernbusiness
-
-
- Die wertvollste Ressource in Ihrem Unternehmen ist Aufmerksamkeit. Jede Stunde, die Ihr Marketing-Team mit "Plugin-Updates" oder dem Debugging von [zerschossenen Layouts nach Updates](/blog/why-websites-break-after-updates) verbringt, fehlt bei der strategischen Marktbearbeitung.
-
-
-
-
-
- Unternehmen, die auf eine moderne Architektur setzen, reduzieren ihre Entwicklungszeit um ca. 30-40 %, da komplexe Infrastruktur-Management-Prozesse entfallen [Source: Forrester].
-
-
-
Der "Haken" an der Sache (Ehrliche Analyse)
-
-
- Ich bin kein Freund von einseitigem Marketing. Ein No-CMS-Ansatz ist nicht für jeden die richtige Lösung. Es erfordert ein gewisses Verständnis für strukturierte Workflows.
-
-
-
-
-
- Kein "Drag-and-Drop": Wer täglich Layouts komplett umwerfen will, ohne die Markenrichtlinien zu beachten, wird sich eingeschränkt fühlen.
-
-
- Initialer Setup-Aufwand: Die Architektur muss einmalig sauber von einem Experten aufgebaut werden.
-
-
-
-
-
Wann ist dieser minimalistische Weg für Sie richtig?
-
-
- Ich arbeite für Entscheider, deren Kerngeschäft nicht das Betreiben einer IT-Infrastruktur ist. Wenn Sie eine Website wollen, die einfach immer online, immer schnell und absolut sicher ist, dann ist die technische Reduktion Ihr stärkster Hebel.
-
-
-
-
-
Fazit: Simplizität ist das neue High-End
-
-
- Die besten Systeme sind die, die man im Alltag nicht spürt, weil sie keine Probleme verursachen. In einer Welt voller [langsamer Ladezeiten](/blog/slow-loading-costs-customers) und Sicherheitslücken ist eine radikal reduzierte Architektur der ultimative Wettbewerbsvorteil.
-
-
- Lassen Sie uns den Ballast abwerfen. Maximale Wirkung bei minimalem technischem Overhead. Ihr Erfolg verdient dieses effiziente Fundament.
-
-
-
-
Ist ein 'No-CMS' Ansatz auch für Nicht-Techniker geeignet?
-
- Ja, absolut. Über moderne Editoren wie Front Matter oder spezialisierte Git-CMS-Interfaces können auch Marketing-Teams Inhalte bearbeiten, ohne jemals Code sehen zu müssen – bei voller Sicherheit.
-
-
Wie hoch ist die Ersparnis bei den Wartungskosten?
-
- In der Regel sinken die direkten Wartungskosten um bis zu 60 %, da manuelle Sicherheits-Updates für Plugins, Themes und Core-Systeme komplett entfallen.
-
-
Was passiert bei einem Hacker-Angriff?
-
- Da es keine Datenbank und kein PHP-Backend gibt, das live auf dem Server ausgeführt wird, existiert faktisch keine Angriffsfläche für klassische Web-Exploits wie SQL-Injections.
-
-
\ No newline at end of file
diff --git a/apps/web/content/blog/no-us-cloud-platforms.mdx b/apps/web/content/blog/no-us-cloud-platforms.mdx
deleted file mode 100644
index f71a550..0000000
--- a/apps/web/content/blog/no-us-cloud-platforms.mdx
+++ /dev/null
@@ -1,166 +0,0 @@
----
-title: "US-Cloud-Exit & Souveränität: Warum lokale Infrastruktur der wahre B2B-Standard ist"
-thumbnail: "/blog/no-us-cloud-platforms.png"
-description: "Erfahren Sie, wie der US CLOUD Act Ihre Daten bedroht und warum europäische Infrastruktur nicht nur sicherer, sondern durch Latenzvorteile auch profitabler ist."
-date: "2026-02-07"
-tags: ["cloud", "privacy", "infrastructure", "compliance"]
----
-
-
- "Die Daten liegen sicher in der Cloud." – Dieser Satz ist heute oft eine gefährliche Halbwahrheit, die das rechtliche Fundament Ihres Unternehmens untergraben kann.
-
-
-
- In meiner Arbeit als Digital Architect begegne ich unzähligen Unternehmen, die die Kontrolle über ihre wichtigsten Assets schleichend verloren haben. Sie sind gefangen in einer Architektur der Abhängigkeit.
-
-
-
- Ich zeige Ihnen, warum lokale Datenhoheit kein nostalgischer Rückzug, sondern der entscheidende Hebel für Sicherheit, Compliance und Performance im Jahr 2025 ist.
-
-
-
-
-
-
-
Das Märchen von der sorglosen US-Cloud
-
-
- Die großen Hyper-Scaler bieten Bequemlichkeit und eine schier endlose Skalierbarkeit. Doch diese Bequemlichkeit hat einen Preis, den viele B2B-Entscheider erst zu spät auf der Rechnung haben: Ihre Souveränität.
-
-
-
- Durch Gesetze wie den **US CLOUD Act** können US-Behörden Zugriff auf Daten verlangen, die auf Servern von US-Unternehmen liegen – völlig ungeachtet dessen, ob diese physisch in Frankfurt, Paris oder Dublin stehen. In einer Welt, in der [Datenschutz-Konformität](/blog/gdpr-conformity-system-approach) ein ultimativer Wettbewerbsvorteil ist, stellt dies ein massives strategisches Risiko dar.
-
-
-
-
-
-
-
- Studien von Deloitte zeigen, dass über 70% der Organisationen weltweit besorgt über den Datenschutz in der Cloud sind. Besonders für europäische Akteure ist die Lage prekär: Rund 60% der Unternehmen in der EU äußern Bedenken hinsichtlich der Auswirkungen des Cloud Acts auf ihre sensiblen Geschäftsgeheimnisse.
-
-
-
-
-
Technologische Latenz: Der versteckte Kostenfaktor
-
-
- Technologie ist niemals neutral, und Geografie ist kein irrelevantes Detail. Wer auf US-zentrische Infrastrukturen setzt, kämpft oft mit physikalischen Grenzen. Die Transatlantik-Latenz ist ein realer Performance-Killer. Research des Nielsen Norman Group zeigt, dass Nutzer Verzögerungen über 250-400ms als störend wahrnehmen – ein Schwellenwert, der bei US-basierten Ressourcen für europäische Nutzer schnell überschritten wird.
-
-
-
-
-
-
-
- Niedrige Latenz ist kein "Nice-to-have". Wie ich in meinem [Google PageSpeed Guide](/blog/google-pagespeed-guide-warum-ladezeit-ihr-wichtigster-b2b-umsatzhebel-ist) erläutere, korreliert die Ladegeschwindigkeit direkt mit der Conversion-Rate und dem Google-Ranking. Webseiten, die lokal gehostet werden, vermeiden die physikalischen Umwege über Überseekabel und liefern Daten dort aus, wo sie gebraucht werden.
-
-
-
Die kritische Distanz: Der Haken an der Sache
-
-
- Als Digital Architect bin ich es Ihnen schuldig, auch die Kehrseite zu beleuchten. Ein kompletter Verzicht auf US-Plattformen erfordert Disziplin und oft ein höheres Initial-Investment in die Architektur.
-
-
-
-
-
- Der "Haken" ist die [Vermeidung von Vendor Lock-ins](/blog/builder-systems-threaten-independence). Wer souverän sein will, kann nicht einfach das günstigste Standard-Template von der Stange nehmen. Es erfordert eine [Build-First-Strategie](/blog/build-first-digital-architecture), die digitale Assets als echtes Unternehmenseigentum begreift.
-
-
-
Mein Ansatz: Die "High-Fidelity" Infrastruktur
-
-
- Ich baue Systeme für Unternehmen, die ihre IT nicht als Kostenstelle, sondern als strategische Festung sehen. Souveränität bedeutet bei mir Premium-Protection durch drei Säulen:
-
-
-
-
- Physische Souveränität: Nutzung zertifizierter Rechenzentren unter rein europäischer Jurisdiktion. Ihre Daten verlassen niemals diesen Rechtsraum.
-
-
- Technologische Unabhängigkeit: Konsequenter Einsatz von Open-Source-Standards statt proprietärer US-APIs. Das schützt vor Preisdiktaten und Abschaltungen.
-
-
- Performance-Optimierung: Edge-Computing innerhalb der EU für TTFB-Werte (Time To First Byte), die im US-Hosting physikalisch unmöglich sind.
-
-
-
-
-
-
-
-
- Ein [professionelles Hosting](/blog/professional-hosting-operations) ist das Fundament für alles Weitere. Wer hier spart, zahlt später doppelt – durch Rechtsrisiken oder verlorene Kunden, die aufgrund [langsamer Ladezeiten](/blog/slow-loading-costs-customers) abspringen.
-
-
-
-
-
Souveränität als messbarer ROI
-
-
- In einer geopolitisch instabilen Welt ist "Data Residency" ein hartes Verkaufsargument im B2B-Sektor. In Projekten für Marktführer sehe ich immer wieder: Kunden vertrauen Unternehmen mehr, die ihre Daten proaktiv schützen (Stichwort: [Websites ohne Cookie-Banner](/blog/website-without-cookie-banners)).
-
-
-
-
-
- Die Investition in eine unabhängige, europäische Architektur sichert die [Langlebigkeit Ihrer Software](/blog/digital-longevity-architecture). Sie bauen kein Kartenhaus auf fremdem Grund, sondern eine digitale Immobilie auf Ihrem eigenen Fundament.
-
-
-
-
-
-
-
Fazit: Ihr Business, Ihre Regeln
-
-
- Holen Sie sich die Kontrolle über Ihre Daten zurück. Souveränität ist keine bloße Compliance-Anforderung, sondern eine strategische Entscheidung für Qualität und Unabhängigkeit.
-
-
-
- Ich begleite Sie dabei, eine Architektur zu erschaffen, die so eigenständig ist wie Ihre Vision. Lassen wir Ihre Daten dort, wo sie hingehören: In Ihrem direkten Einflussbereich.
-
-
-
-
Was ist das Hauptproblem am US CLOUD Act für deutsche Firmen?
-
- Der CLOUD Act verpflichtet US-Provider zur Herausgabe von Daten an US-Behörden, selbst wenn diese in deutschen Rechenzentren liegen. Dies führt zu einem direkten Konflikt mit der DSGVO und gefährdet die Datensouveränität.
-
-
-
Ist europäisches Hosting wirklich schneller?
-
- Ja, aufgrund der kürzeren Distanz (Latenz). Ein Server in Frankfurt liefert Daten an deutsche Nutzer in ca. 10-20ms aus, während ein US-Server oft über 100ms benötigt, was die User Experience und SEO negativ beeinflusst.
-
-
-
Muss ich auf Komfort verzichten, wenn ich US-Plattformen meide?
-
- Nur bedingt. Moderne europäische Cloud-Anbieter bieten mittlerweile ähnliche Automatisierungs-Tools, erfordern aber beim Setup ein tieferes technisches Verständnis, um eine vergleichbare Skalierbarkeit zu erreichen.
-
-
\ No newline at end of file
diff --git a/apps/web/content/blog/professional-hosting-operations.mdx b/apps/web/content/blog/professional-hosting-operations.mdx
deleted file mode 100644
index 6a09a80..0000000
--- a/apps/web/content/blog/professional-hosting-operations.mdx
+++ /dev/null
@@ -1,156 +0,0 @@
----
-title: "Hosting & Infrastructure Overhaul: Das Fundament digitaler Exzellenz"
-thumbnail: "/blog/professional-hosting-operations.png"
-description: "Vermeiden Sie teure Downtimes und Shared-Hosting-Risiken. Erfahren Sie, wie Industrial-Grade Infrastructure als Code (IaC) Ihre B2B-Plattform unverwüstlich macht."
-date: "2026-01-29"
-tags: ["hosting", "operations", "infrastructure"]
----
-
-
- Ein brillanter Webauftritt ist wertlos, wenn er im entscheidenden Moment nicht erreichbar ist. In der Welt des High-End B2B-Marketing ist die zugrunde liegende Infrastruktur kein technisches Detail, sondern eine strategische Versicherung.
-
-
- Hosting ist für mich kein notwendiges Übel, sondern das schlagende Herz Ihrer digitalen Präsenz. Wer hier spart, riskiert nicht nur Ladezeiten, sondern seine gesamte Marken-Reputation.
-
-
- Ich zeige Ihnen, wie Industrial-Grade Operations und moderne Cloud-Architekturen dafür sorgen, dass Sie auch bei massiven Traffic-Spitzen ruhig schlafen können, während der Wettbewerb unter der Last zusammenbricht.
-
-
-
-
-
Das Märchen vom 'Billig-Hosting'
-
-
- Viele Unternehmen investieren Unsummen in glänzende User Interfaces, während das technische Fundament auf wackeligen Shared-Hosting-Beinen steht. Das Problem: Websites auf Shared Hosting erleben oft deutlich langsamere Ladezeiten als solche auf dedizierten Servern, bedingt durch Ressourcen-Contention (Quelle: Google Developers).
-
-
-
- Noch kritischer ist der Sicherheitsaspekt. Shared-Hosting-Umgebungen bergen system immanente Risiken, da eine einzige Schwachstelle in einer Nachbar-Website potenziell alle anderen Präsenzen auf demselben Server infizieren kann (Quelle: OWASP). Wer seine [technischen Altlasten](/blog/slow-loading-costs-customers) ignoriert, spielt digitales Russisch Roulette mit seinen Kundendaten.
-
-
-
-
-
-
-
- Zudem führen geteilte CPU- und Bandbreiten-Ressourcen zu massiven Performance-Fluktuationen während Stoßzeiten (Quelle: HTTP Archive). In meiner Welt gibt es keine Kompromisse bei der Erreichbarkeit. Ihre Marke verdient eine eigene Umlaufbahn.
-
-
-
Der wirtschaftliche Case: Was kostet Stillstand?
-
-
- Downtime ist kein IT-Problem, sondern ein massiver Umsatzkiller. Laut Gartner belaufen sich die durchschnittlichen Kosten für IT-Downtime auf stolze **5.600 $ pro Minute**.
-
-
-
-
-
- Trotz dieser Zahlen ergab eine Studie des Uptime Institute, dass über ein Drittel aller Organisationen innerhalb von drei Jahren einen signifikanten, ungeplanten Ausfall verkraften mussten. Im B2B-Kontext, wo Vertrauen die härteste Währung ist, wiegt der Reputationsschaden oft schwerer als der direkte finanzielle Verlust. Ein stabiles System ist daher ein [entscheidender Wettbewerbsvorteil](/blog/digital-longevity-architecture).
-
-
-
-
-
-
-
Infrastruktur als Code: Die moderne Festung
-
-
- Ich konfiguriere Server nicht manuell durch Klicken in Web-Interfaces. Ich nutze **Infrastructure as Code (IaC)**. Das bedeutet: Die gesamte Umgebung ist in Code definiert, versionierbar und jederzeit exakt reproduzierbar.
-
-
-
- Der Effekt ist messbar: High-Performing Teams, die IaC einsetzen, verzeichnen laut dem Puppet State of DevOps Report **50% weniger ungeplante Ausfälle**. Zudem lässt sich die Provisionierungszeit für neue Infrastruktur um bis zu 80% reduzieren (Quelle: Deloitte).
-
-
-
-
-
-
-
- Sollte ein Rechenzentrum physikalisch ausfallen, "erwacht" Ihr System durch automatisierte Failover-Prozesse an einem anderen Standort in Minuten wieder zum Leben. Das ist das Niveau von Hochverfügbarkeit, das ich für meine Kunden realisiere.
-
-
-
-
Meine Prinzipien für reibungslose Operations
-
-
- Edge Computing & Caching: Die Auslieferung erfolgt am Standort des Nutzers. Ob Singapur oder Hamburg – Ladezeiten sind minimal. (Siehe auch: [Google PageSpeed Guide](/blog/google-pagespeed-guide-warum-ladezeit-ihr-wichtigster-b2b-umsatzhebel-ist)).
-
-
- Automatisierte Rollbacks: Jede Änderung kann in Sekunden rückgängig gemacht werden, falls Probleme auftreten. Keine Angst vor Fehlern.
-
-
- Self-Healing Architecture: Systeme erkennen Lastspitzen oder Defekte selbstständig und skalieren oder reparieren sich, ohne menschliches Eingreifen.
-
-
-
-
-
Der Haken an der Sache: Die Realität der Hochverfügbarkeit
-
-
- Transparenz ist die Basis einer guten Partnerschaft. Eine Infrastruktur auf industriellem Niveau hat ihren "Preis" – technologisch wie finanziell.
-
-
-
-
-
- Eine Cloud-Native Architektur erfordert spezialisiertes Know-how. Wer [Vendor Lock-In vermeiden](/blog/builder-systems-threaten-independence) will, muss in die Eigenständigkeit investieren. Wer jedoch einmal den Sprung von "es läuft irgendwie" zu einer professionell gemanagten Infrastruktur geschafft hat, sieht diese nicht mehr als Kostenstelle, sondern als stabilen [Digital Asset](/blog/build-first-digital-architecture).
-
-
-
-
-
Fazit: Ihre Plattform verdient ein industrielles Fundament
-
-
- Lassen wir das manuelle Basteln im Maschinenraum hinter uns. Eine moderne Website ist eine geschäftskritische Anwendung und muss auch so behandelt werden. Laut DORA-Studien stellen Organisationen mit reifen DevOps-Praktiken 200-mal häufiger Code bereit und erholen sich 24-mal schneller von Vorfällen (Quelle: DORA).
-
-
-
- Ich baue Ihnen eine Umgebung, die mit Ihren Ambitionen mitwächst. Sicher. Schnell. Skalierbar. Gönnen Sie Ihrem Business die technologische Souveränität, die es verdient, und befreien Sie sich von den Limitierungen veralteter Hosting-Modelle.
-
-
-
-
Warum ist Shared Hosting ein Risiko für mein B2B-Unternehmen?
- Im Shared Hosting teilen Sie sich Ressourcen mit fremden Webseiten, was bei deren Überlastung Ihre Seite verlangsamt. Zudem erhöht es das Sicherheitsrisiko (Cross-Site Contamination), da ein Hack beim Nachbarn auch Ihre Präsenz gefährden kann.
-
-
Was ist der Vorteil von Infrastructure as Code (IaC)?
- IaC ersetzt manuelles Server-Klicken durch automatisierte Skripte, was menschliche Fehler eliminiert und die Infrastruktur exakt reproduzierbar macht. Dies ermöglicht schnellere Disaster Recovery und eine 50% geringere Ausfallwahrscheinlichkeit.
-
-
Wie hoch sind die Kosten für eine Stunde Website-Downtime?
- Für den Mittelstand und Enterprises liegen die Kosten oft bei über 100.000 $ pro Stunde, wenn man entgangene Leads, Marketing-Spend und Reputationsverlust einrechnet. Eine stabile Hosting-Architektur amortisiert sich daher meist schon nach dem ersten verhinderten Ausfall.
-
\ No newline at end of file
diff --git a/apps/web/content/blog/responsive-design-high-fidelity.mdx b/apps/web/content/blog/responsive-design-high-fidelity.mdx
deleted file mode 100644
index 3a21a06..0000000
--- a/apps/web/content/blog/responsive-design-high-fidelity.mdx
+++ /dev/null
@@ -1,171 +0,0 @@
----
-title: "Responsive Design: Warum mobile Exzellenz über Ihren B2B-Umsatz entscheidet"
-thumbnail: "/blog/responsive-design-high-fidelity.png"
-description: "Mehr als nur Boxen rücken: Erfahren Sie, wie architektonische Präzision, Core Web Vitals und plattformübergreifende Ergonomie Ihre globale Conversion-Rate massiv steigern."
-date: "2026-01-27"
-tags: ["design", "ux", "performance"]
----
-
-
- Im modernen B2B-Sektor bedeutet "Responsive" heute weit mehr als nur das automatische Verschieben von Layout-Elementen. Es ist die Grundvoraussetzung für digitales Vertrauen.
-
-
- In meiner Welt als Digital Architect ist jedes Endgerät eine eigene Bühne mit spezifischen Regeln, Interaktionsmustern und Erwartungshaltungen.
-
-
- Ich zeige Ihnen, warum Responsive-Exzellenz kein "Nice-to-have", sondern der entscheidende Hebel für Ihre globale Conversion-Rate und Markenautorität ist.
-
-
-
-
-
-
TL;DR: Die Fakten auf den Tisch
-
- Mobile Endgeräte dominieren den weltweiten Traffic. Wer hier auf Standard-Lösungen setzt, verschenkt bares Geld. Eine Optimierung der Ladezeit und UX führt direkt zu höheren Conversion-Rates und geringeren Absprungraten. Responsive Design ist heute Performance-Engineering.
-
-
-
-
-
-
Jenseits der Standard-Breakpoints
-
- Die meisten Agenturen nutzen simple Raster, die auf dem Desktop entworfen wurden und auf dem Smartphone lediglich "irgendwie funktionieren". Das Ergebnis ist im B2B-Kontext oft fatal: zu kleine Texte, unbedienbare Formularfelder und Bilder, die das Layout sprengen oder die Ladezeit in den Keller ziehen.
-
-
- Daten von [Statista](https://www.statista.com) zeigen deutlich: Mobile Geräte generierten bereits Ende 2023 über 54% des globalen Traffics. Aktuelle Prognosen für 2025 sehen diesen Wert sogar bei über 62%. Wer hier patzt, ignoriert die Mehrheit seiner potenziellen Kunden.
-
-
-
-
-
-
-
- Ich betrachte Responsive Design als architektonische Präzisionsleistung. Wir gestalten die Experience für den Einkäufer im Zug ebenso perfekt wie für den CTO am 4K-Monitor im Office. Fokus und Hierarchie müssen auf jedem Screen neu definiert werden, um [langsame Ladezeiten und technische Altlasten](/blog/slow-loading-costs-customers) zu vermeiden.
-
-
-
-
- Responsive Design ist eng mit der Ladegeschwindigkeit verknüpft. Google Developers fand heraus, dass 53% der mobilen Nutzer eine Seite verlassen, wenn sie länger als drei Sekunden lädt. Dies ist kein reines IT-Problem, sondern ein massives Umsatzrisiko.
-
-
-
-
-
- Ein gut umgesetztes System reduziert die [versteckten Kosten von unnötigen Plugins](/blog/hidden-costs-of-wordpress-plugins) und setzt auf schlanke, hocheffiziente Architekturen. Das Ziel: Jede Millisekunde zählt für den ROI.
-
-
-
-
-
Technische Säulen meiner Umsetzung
-Wie erreichen wir diese technische Perfektion, die über den Standard hinausgeht? Durch konsequentes Engineering:
-
-
-
- Fluid Typography & Spacing: Wir nutzen keine starren Pixel-Werte. Alles atmet und skaliert harmonisch mit der Viewport-Größe (Clamp-Funktionen).
-
-
- Adaptive Media: Durch `srcset` und moderne Formate wie AVIF werden Medien exakt in der Größe ausgeliefert, die das Display benötigt. Kein Byte wird verschwendet.
-
-
- Core Web Vitals Fokus: Jedes responsive Element wird auf LCP (Largest Contentful Paint) und CLS (Cumulative Layout Shift) optimiert, um Google-Rankings zu sichern.
-
-
-
-
Kontextsensitive Ergonomie
-
- In meiner Architektur passen wir nicht nur das Layout an, sondern oft auch die Interaktionslogik. Während am Desktop Hover-Effekte informieren, benötigen mobile User großzügige Touch-Targets und intuitive Wischgesten. Das ist digitale Ergonomie auf Boutique-Niveau.
-
-
-
-
-
Der Haken an der Sache (Devil's Advocate)
-
- Warum macht das nicht jeder so? Ganz einfach: Echte responsive Exzellenz ist aufwendig.
-
-
-
-
-
- Standard-Templates führen oft zu einem "Einheitsbrei", der Ihre Marke verwässert. Warum das ein Risiko ist, erkläre ich in meinem Artikel [Warum Templates Ihre Marken-Identität verwässern](/blog/why-no-templates-matter).
-
-
-
-
-
Responsive Design als Strategisches Asset
-
- Laut Nielsen Norman Group führt eine positive mobile Experience direkt zu gesteigerter Kundenzufriedenheit und Loyalität. Im B2B-Mittelstand ist die Website oft der erste Kontaktpunkt. Ein holpriges mobiles Erlebnis signalisiert technologischen Rückstand.
-
-
-
-
-
-
-
- Durch den Einsatz von [Clean Code Prinzipien](/blog/clean-code-for-business-value) schaffen wir eine Basis, die nicht nur heute funktioniert, sondern auch für zukünftige Geräteklassen (wie Foldables oder AR-Interfaces) bereit ist. Wir bauen kein Wegwerf-Produkt, sondern ein langlebiges digitales Asset.
-
-
-
Fazit: Konsistenz schafft Vertrauen
-
- Ihre Marke muss sich auf dem Smartphone in der Bahn exakt so wertig anfühlen wie im Konferenzraum auf dem 85-Zoll-Screen. Responsive Design ist die Kunst, technologische Komplexität in eine nahtlose, einfache Nutzerführung zu übersetzen.
-
-
- Präzision im Detail, Harmonie im Ganzen. Wenn Sie bereit sind, die Limitationen von Standard-Grids hinter sich zu lassen und eine Website zu bauen, die auf jedem Endgerät konvertiert, sollten wir sprechen.
-
-
-
-
-
-
Was ist der wichtigste Faktor für mobiles Responsive Design?
-
- Neben der visuellen Anpassung ist die Ladezeit (Performance) entscheidend. Mobile Nutzer haben oft instabile Verbindungen, weshalb radikale Asset-Optimierung oberste Priorität hat.
-
-
-
Warum reichen Standard-Breakpoints für B2B nicht aus?
-
- B2B-Entscheider nutzen eine enorme Bandbreite an Geräten, von ultra-hochauflösenden Monitoren bis zu älteren Smartphones. Ein starres Raster ignoriert die feinen Abstufungen dazwischen und verschlechtert die UX.
-
-
-
Wie beeinflusst Responsive Design mein Google-Ranking?
-
- Google nutzt das Mobile-First-Indexing. Eine Seite, die mobil schlecht performt oder Layout-Fehler (CLS) aufweist, wird systematisch in den Suchergebnissen abgestraft.
-
-
\ No newline at end of file
diff --git a/apps/web/content/blog/slow-loading-costs-customers.mdx b/apps/web/content/blog/slow-loading-costs-customers.mdx
deleted file mode 100644
index b06a812..0000000
--- a/apps/web/content/blog/slow-loading-costs-customers.mdx
+++ /dev/null
@@ -1,151 +0,0 @@
----
-title: "Der Preis der Trägheit: Wie technische Altlasten Ihren B2B-Umsatz vernichten"
-thumbnail: "/blog/slow-loading-costs-customers.png"
-description: "53% der Nutzer springen nach 3 Sekunden ab. Erfahren Sie, warum Web-Performance kein IT-Gadget, sondern Ihr wichtigster betriebswirtschaftlicher Hebel ist."
-date: "2026-02-14"
-tags: ["performance", "business-strategy", "conversion-optimization"]
----
-
-
- Zeit ist im modernen Web die härteste Währung – und im B2B-Sektor oft der entscheidende Differenzierator zwischen Marktführerschaft und Bedeutungslosigkeit.
-
-
- In meiner Laufbahn als Digital Architect habe ich miterlebt, wie Millisekunden über den Erfolg komplexer Geschäftsmodelle entscheiden. Wer technische Altlasten ignoriert, zahlt Zinsen in Form von massiven Kundenverlusten.
-
-
- Bis das digitale Business schließlich an technischer Zahlungsunfähigkeit scheitert. Performance ist kein "Nice-to-have", sondern das Fundament Ihrer digitalen Reputation.
-
-
-
-
Inhaltsverzeichnis
- 1. [Der wirtschaftliche Case für Speed](#der-wirtschaftliche-case)
- 2. [Die Psychologie des digitalen Wartens](#psychologie)
- 3. [Wo die Schulden in Ihrem System lauern](#system-schulden)
- 4. [Der Haken an der Sache: Die Wahrheit über Refactoring](#der-haken)
- 5. [Fazit & FAQ](#fazit)
-
-
-
Zinsen auf schlechte technische Entscheidungen
-
-
- Technik-Schulden (Technical Debt) entstehen oft schleichend. Man wählt heute die schnelle, vermeintlich günstige Lösung eines Baukastensystems, um Zeit zu sparen. Doch wie ich bereits in meinem Artikel über [Baukasten-Systeme](/blog/builder-systems-threaten-independence) erläutert habe, ist diese Entscheidung ein digitaler Kredit mit extrem hohen Zinsen.
-
-
-
- Bei der Performance äußert sich das in trägen Ladezeiten, die sich wie Blei auf Ihre Conversion-Rate legen. Die Zahlen der Industrie sind hierbei unmissverständlich:
-
-
-
-
-
- Jede Sekunde Verzögerung zwischen null und fünf Sekunden senkt die Abschlussquote im Schnitt um 4,42 %. Das ist kein bloßes IT-Thema – das ist ein massives betriebswirtschaftliches Risiko. In B2B-Umgebungen kann jede zusätzliche Sekunde die Conversion sogar um bis zu 20 % drücken.
-
-
-
-
-graph TD
- A[Träge Website] --> B[Nutzer-Frust]
- B --> C[Hohe Absprungrate]
- C --> D[SEO-Ranking Verlust]
- D --> E[Umsatzeinbußen]
- E --> A
-
-
-
-
Die Psychologie des digitalen Wartens
-
-
- Wussten Sie, dass Nutzer oft bereits in den ersten 50 Millisekunden ihre Meinung über eine Website bilden? Die menschliche Wahrnehmung von Zeit im Internet ist völlig verzerrt. Eine Sekunde Wartezeit fühlt sich digital wie eine kleine Ewigkeit an.
-
-
-
-
-
- Wenn eine Seite nicht sofort reagiert, sendet dies ein Signal von Unzuverlässigkeit und Inkompetenz. Der Nutzer fragt sich unbewusst: "Wenn sie schon ihre Website nicht im Griff haben, wie gehen sie dann mit sensiblen Projektdaten um?" Ein performantes System hingegen strahlt Präzision aus, noch bevor das erste Wort gelesen wurde. Dies ist eng verknüpft mit [Clean Code Strategien](/blog/clean-code-for-business-value), die langfristige Stabilität garantieren.
-
-
-
-
-
-
-
Wo die Schulden in Ihrem System wirklich lauern
-
-
- In meiner Analyse moderner Infrastrukturen begegnen mir immer wieder die gleichen drei Quellen für technische Altlasten. Diese zu bereinigen ist der größte Hebel für Ihre digitale Rendite:
-
-
-
-
- Legacy Script Bloat: Veraltete Marketing-Tracker und 47 WordPress-Plugins, die den Browser blockieren. Ein Wechsel zu einer [Headless-Architektur](/blog/maintenance-for-headless-systems) eliminiert diesen Ballast radikal.
-
-
- Architektonische Trägheit: Dynamische Datenbankabfragen bei jedem Klick, wo statische Antworten möglich wären. Wir liefern Content in Lichtgeschwindigkeit.
-
-
- Mobile Vernachlässigung: 53% der mobilen Besucher verlassen eine Seite, die länger als 3 Sekunden lädt. [Mobile Exzellenz](/blog/responsive-design-high-fidelity) ist heute Pflicht.
-
-
-
-
-
-
Der Haken an der Sache: Die Wahrheit über Performance
-
-
- Ich wäre kein ehrlicher Architekt, wenn ich behaupten würde, dass maximale Performance geschenkt ist. Es gibt klare Herausforderungen bei der Eliminierung technischer Schulden:
-
-
-
-
-
- Ein strategisches Refactoring bedeutet oft, sich von bequemen, aber langsamen "Drag-and-Drop" Editoren zu verabschieden. Es erfordert eine [Build-First Mentalität](/blog/build-first-digital-architecture) statt dem Mieten von Standard-SaaS-Lösungen.
-
-
-
-
-
Fazit: Befreien Sie Ihr Business
-
-
- Technische Schulden sind eine unsichtbare Bremse für Ihr Wachstum. In einem Markt, in dem 79% der unzufriedenen Shopper nie wieder zurückkehren, können Sie sich langsame Ladezeiten schlicht nicht leisten.
-
-
-
- Ein System, das durch Effizienz und Klarheit überzeugt, ist nicht nur ein Werkzeug – es ist ein digitales Asset, das Ihren Unternehmenswert steigert. Ihr Business verdient es, unbeschwert und frei von Altlasten zu skalieren.
-
-
-
-
-
-
Warum ist die Ladezeit für B2B wichtiger als für B2C?
- B2B-Entscheider haben oft wenig Zeit und nutzen professionelle Tools. Eine langsame Website wird hier direkt mit mangelnder Professionalität und veralteten Prozessen gleichgesetzt, was den gesamten Sales-Cycle gefährdet.
-
-
Was ist ein guter PageSpeed-Score für Unternehmen?
- Ein Lighthouse-Score von über 90 in allen Kategorien (Performance, Accessibility, Best Practices, SEO) sollte der Standard sein. Besonders die Core Web Vitals wie LCP (unter 2,5s) sind für das Google-Ranking entscheidend.
-
-
Kann ich meine bestehende WordPress-Seite einfach schneller machen?
- Bis zu einem gewissen Punkt ja, durch Caching und Plugin-Reduktion. Um jedoch echte Spitzenwerte zu erreichen, ist oft der Wechsel zu einer modernen, statisch generierten Architektur (Jamstack) nötig.
-
\ No newline at end of file
diff --git a/apps/web/content/blog/website-as-a-service.mdx b/apps/web/content/blog/website-as-a-service.mdx
deleted file mode 100644
index 098b3db..0000000
--- a/apps/web/content/blog/website-as-a-service.mdx
+++ /dev/null
@@ -1,110 +0,0 @@
----
-title: "Website as a Service: Warum das Sorglos-Paket der einzig logische Weg für Unternehmer ist"
-thumbnail: "/blog/website-as-a-service.png"
-description: "Vergessen Sie Plugin-Updates, Sicherheitslücken und endlose Stundenabrechnungen. Ein Plädoyer für Websites ohne Overhead und warum Fixpreise den Markt revolutionieren."
-date: "2026-05-06"
-tags: ["business", "management", "strategy"]
----
-
-
- Die meisten Unternehmer wollen keine Website besitzen – sie wollen die Ergebnisse, die eine professionelle Website liefert: Sichtbarkeit, Vertrauen, qualifizierte Anfragen.
-
-
- Trotzdem verbringen unzählige Geschäftsführer und Marketing-Teams Stunden damit, Sicherheits-Updates einzuspielen, sich in Baukästen einzuarbeiten oder mit Support-Hotlines zu telefonieren, weil ein simples Plugin die Seite zerschossen hat. Das ist betriebswirtschaftlicher Wahnsinn.
-
-
- In meiner Arbeit als Digital Architect habe ich das Modell "Website as a Service" (WaaS) perfektioniert. Es ist die radikalste und fairste Antwort auf die Dysfunktionen der klassischen Webentwicklung.
-
-
-
-
-
Der Mythos der "kostenlosen" Website
-
-
- Ein Baukasten-System kostet vielleicht nur 15 Euro im Monat. Ein Premium-WordPress-Theme gibt es für 50 Euro. Doch die wahren Kosten verstecken sich in der Zeit. Wenn ein Geschäftsführer oder Head of Marketing, dessen Zeit konservativ geschätzt 150 Euro pro Stunde wert ist, sich nur fünf Stunden im Monat mit technischen Problemen seiner Website beschäftigt, kostet diese Seite in Wahrheit 750 Euro im Monat.
-
-
-
- Dazu kommt das Opportunitätsrisiko: Was hätte das Unternehmen in diesen fünf Stunden erreichen können? Ein entscheidendes Verkaufsgespräch mehr? Eine strategische Prozessoptimierung? Die Verwaltung von IT-Infrastruktur sollte niemals die Kernaufgabe eines Nicht-IT-Unternehmens sein.
-
-
-
-
-
Website as a Service: Das Ende des Overheads
-
-
- Der Ansatz "Website as a Service" (WaaS) – bei mir das "Sorglos-Paket" genannt – dreht dieses Modell komplett um. Sie mieten keine Software, Sie buchen eine fortlaufende Dienstleistung mit absoluter Kostensicherheit.
-
-
-
-
- graph LR
- A["Klassisch (WordPress/Baukasten)"] --> B["Versteckte Zeitkosten"]
- B --> C["Sicherheitsrisiken"]
- C --> D["Frust bei Änderungen"]
-
- E["Sorglos-Paket (WaaS)"] --> F["Fixer Jahresbeitrag"]
- F --> G["Zero Overhead"]
- G --> H["Skalierbares Business"]
-
- style A fill:#f87171,stroke:#333
- style E fill:#4ade80,stroke:#333
-
-
-
-
- Bei meinem Sorglos-Paket ist die Prämisse kompromisslos einfach: Zero Overhead für die Technik. Sie kümmern sich um Ihr Geschäft und schreiben Ihre Fachartikel oder News ganz entspannt im Headless CMS. Alles andere – Server-Wartung, Security-Updates, Performance-Monitoring oder Layout-Anpassungen – läuft unsichtbar im Hintergrund ab. Keine zerschossenen Plugins, keine Angst vor fehlerhaften Updates.
-
-
-
Sicherheit durch Architektur (Security by Design)
-
-
- Warum sind klassische CMS wie WordPress so angreifbar? Weil sie dynamisch sind. Jeder Seitenaufruf triggert eine Datenbankabfrage, und Millionen von Websites nutzen dieselben veralteten Plugins, was sie zu einem perfekten Ziel für automatisierte Hacker-Skripte macht.
-
-
-
- In einem WaaS-Modell übernehme ich als Entwickler nicht nur die inhaltlichen Änderungen, sondern baue die Seite von Grund auf auf einer modernen, statischen Architektur (Jamstack / Next.js). Das bedeutet: Die Seite wird im Vorfeld generiert. Es gibt keine Datenbank, die live am Netz hängt und gehackt werden könnte.
-
-
-
-
-
- Das Ergebnis: Die Seite kann faktisch nicht gehackt werden. [Updates und Wartung](/blog/why-websites-break-after-updates) laufen unsichtbar im Hintergrund ab, und die Ladezeiten sind extrem optimiert, da nur statische Dateien (HTML/CSS/JS) vom Server ausgeliefert werden.
-
-
-
-
-
Finanzielle Vorhersehbarkeit statt Blackbox
-
-
- "Wir haben 2 Stunden gebraucht, um das Kontaktformular wieder zum Laufen zu bringen." – Solche Rechnungen gehören mit einem Service-Paket der Vergangenheit an. Ein festes Jahresbudget erlaubt Ihnen eine exakte Finanzplanung.
-
-
-
- Diese Budgetsicherheit ist für B2B-Unternehmen extrem wertvoll. Unvorhergesehene Serverausfälle oder nötige Sicherheits-Patches sind nicht mehr Ihr finanzielles Risiko, sondern mein technisches. Es liegt also in meinem absoluten Eigeninteresse, die Architektur von Tag eins an so robust und fehlerfrei wie möglich zu bauen. Das ist das Prinzip des [strategischen Festpreises](/blog/fixed-price-digital-projects).
-
-
-
-
-
Fazit: Kaufen Sie Zeit, keine Software
-
-
- Eine Website sollte ein stiller Mitarbeiter sein, der 24/7 funktioniert, Leads generiert und Ihr Unternehmen professionell repräsentiert – kein IT-Projekt, das ständig Ihre Aufmerksamkeit fordert. Ein Sorglos-Paket ist nicht einfach nur ein Wartungsvertrag. Es ist die strategische Entscheidung, technischen Ballast abzuwerfen und sich wieder zu 100% auf das eigene Kerngeschäft zu konzentrieren.
-
-
-
-
Welche Änderungen sind im Sorglos-Paket enthalten?
-
- Das Paket umfasst alle **nicht-redaktionellen** Anpassungen, Wartungsarbeiten und Security-Updates. Wenn sich Ihr Angebot ändert, ein neues technisches Feature integriert werden muss oder Layout-Anpassungen nötig sind, setze ich das zeitnah um. Reine redaktionelle Aufgaben (wie das wöchentliche Schreiben neuer Blog-Posts) sind nicht inkludiert, da Sie hierfür über das Headless CMS volle Autonomie besitzen.
-
-
-
Was passiert, wenn wir doch komplett neue Funktionen brauchen?
-
- Große strukturelle Erweiterungen (z.B. der Bau eines komplett neuen Karriere-Portals oder die Integration eines komplexen CRM-Systems) werden als separates Festpreis-Projekt behandelt. Alles, was den bestehenden Rahmen nutzt, ist abgedeckt.
-
-
-
Verlieren wir nicht die Kontrolle über die Technik?
-
- Im Gegenteil: Sie gewinnen Qualitätskontrolle und Sicherheit. Sie haben über das Headless CMS die volle redaktionelle Freiheit für Ihre Inhalte. Was ich Ihnen abnehme, ist die technische Last. Sie können das Layout nicht versehentlich zerschießen und müssen keine Angst vor Datenbank-Fehlern haben. Die Technik bleibt professionell betreut und zu 100% "on brand".
-
-
diff --git a/apps/web/content/blog/website-without-cookie-banners.mdx b/apps/web/content/blog/website-without-cookie-banners.mdx
deleted file mode 100644
index 24ea872..0000000
--- a/apps/web/content/blog/website-without-cookie-banners.mdx
+++ /dev/null
@@ -1,185 +0,0 @@
----
-title: "Websites ohne Cookie-Banner: Warum Privacy by Design der neue B2B-Standard ist"
-thumbnail: "/blog/website-without-cookie-banners.png"
-description: "Cookie-Banner sind ein Zeichen für schlechtes Engineering. Erfahren Sie, wie Sie durch eine Cookie-freie Architektur UX, Performance und DSGVO-Konformität brillant vereinen."
-date: "2026-02-06"
-tags: ["privacy", "ux", "engineering"]
----
-
-
- Ich halte Cookie-Banner für eine der größten Design-Sünden und Vertrauenskiller des modernen Webs. Sie sind das digitale Äquivalent zu einer verschlossenen Tür, an der man erst ein Formular ausfüllen muss, bevor man den Raum betreten darf.
-
-
-
- Diese Banner stören nicht nur den Lesefluss, sondern suggerieren eine Pseudo-Sicherheit, während im Hintergrund oft unkontrolliert Daten abfließen. Vor allem signalisieren sie eines: Ein mangelhaftes technisches Konzept und eine Abhängigkeit von Drittanbietern.
-
-
-
- In diesem Guide zeige ich Ihnen, wie wir durch intelligentes Engineering vollständig ohne Banner auskommen – bei 100 % DSGVO-Konformität und maximaler technischer Souveränität.
-
-
-
-
-
-
-
Das Banner-Paradoxon: Warum wir uns das antun
-
-
- Klassische Websites laden oft ungefragt hunderte Kilobyte an Scripten von Drittanbietern – ein signifikanter Prozentsatz dieser Scripte stammt von US-basierten Konzernen wie Google, Meta oder Adobe. Diese Tools werden für Analytics, Advertising und Content Delivery genutzt, oft ohne dass die Betreiber die volle Kontrolle über den Datenfluss haben.
-
-
-
- Laut [HTTP Archive](https://httparchive.org) enthalten fast alle modernen Websites Third-Party-Scripte. Viele Top-Websites verlassen sich dabei blind auf CDNs von US-Firmen wie Akamai oder Cloudflare. Das Problem: Sobald personenbezogene Daten (wie IP-Adressen) an Server in Drittstaaten übertragen werden, schreibt die DSGVO eine informierte Einwilligung vor. Das Ergebnis ist das tägliche Banner-Chaos.
-
-
-
-
-
- Viele Besucher klicken frustriert auf "Alle akzeptieren", nur um den Content endlich lesen zu können, oder verlassen die Seite sofort wieder (Bounce Rate). Untersuchungen von Institutionen wie dem [Baymard Institute](https://baymard.com) zeigen, dass komplizierte Consent-Mechanismen die Conversion-Rate massiv schädigen können.
-
-
-
- Ich verfolge eine radikal andere Philosophie: Wenn wir keine personenbezogenen Daten abfließen lassen, brauchen wir auch keine Erlaubnis. Es ist eine Frage der technischen Souveränität und des digitalen Anstands. Wer [DSGVO-Konformität als Wettbewerbsvorteil](/blog/gdpr-conformity-system-approach) begreift, baut Vertrauen statt Barrieren.
-
-
-
-
-graph TD
- A["Nutzer besucht Website"] --> B{"Mintel Stack"}
- B --> C["Lokale Assets & Fonts"]
- B --> D["Anonyme Analytics"]
- C --> E["Kein Banner nötig"]
- D --> E
- E --> F["Maximale Conversion"]
-
- A --> G["Standard CMS"]
- G --> H["US-Cloud Scripts"]
- H --> I["Cookie Banner Pflicht"]
- I --> J["Nutzer-Abbruch"]
-
-
-
-
Die unsichtbare Transaktion des Vertrauens
-
-
- Jedes Mal, wenn ein Nutzer Ihre Seite ohne Banner betreten kann, findet eine unsichtbare Transaktion statt: Vertrauensaufbau. Sie signalisieren Ihrem Besucher: "Ich brauche deine persönlichen Daten nicht, um dich von meiner Leistung zu überzeugen." Transparenz und Kontrolle sind laut einer Deloitte-Studie die Schlüsselelemente für Kundenloyalität.
-
-
-
- Unternehmen investieren oft Unsummen in glänzende Oberflächen, während das technische Fundament – etwa durch [versteckte Kosten von Plugins](/blog/hidden-costs-of-wordpress-plugins) – bröckelt. Privatsphäre ist heute ein High-End Feature. Wer seine Infrastruktur beherrscht, braucht keine rechtlichen Krücken.
-
-
-
-
-
- Invasive Tracker und Advertising-Netzwerke, wie sie Google oder Meta betreiben, nutzen Scripte, die tief in die Privatsphäre eingreifen. Wenn Sie stattdessen auf [Analytics ohne Tracking](/blog/analytics-ohne-tracking-dsgvo-konforme-insights-ohne-user-ueberwachung) setzen, erhalten Sie alle geschäftsrelevanten Metriken, ohne Ihre Nutzer zu überwachen.
-
-
-
Mein Weg zu 100 % technischer Souveränität
-
-
- Privacy-first bedeutet für mich nicht Verzicht, sondern intelligenteres Engineering. Wir messen Ihren Erfolg – aber wir brauchen keine personenbezogenen Profile, um zu wissen, ob eine Kampagne funktioniert. In der Realität führen Cookie-Banner oft zu Datenverlusten von bis zu 40%, da Nutzer die Einwilligung verweigern. Ein server-seitiges, anonymes Tracking ist hier deutlich präziser.
-
-
-
-
- Full Local Hosting: Google Fonts, Bibliotheken und sämtliche Scripte liegen direkt auf Ihrer Infrastruktur. Kein Datentransfer zu US-Servern (Privacy by Design).
-
-
- Ethische Telemetrie: Wir nutzen Tools wie Plausible oder Matomo (ohne Cookies), die Nutzerwege messen, ohne Identitäten preiszugeben.
-
-
- Performance-Boost: Ohne schwere Consent-Management-Tools sinkt die Ladezeit massiv. Jede 0,1s schnellere Ladezeit steigert die Conversion um bis zu 8%.
-
-
-
-
-
-
-
-
- Engineering-Exzellenz bedeutet auch, den [US-Cloud-Exit](/blog/no-us-cloud-platforms) konsequent zu vollziehen. Indem wir Assets lokal ausliefern, eliminieren wir die rechtliche Notwendigkeit für Einwilligungen, die durch externe Ressourcenaufrufe entstehen würden.
-
-
-
Der Haken an der Sache (Devil's Advocate)
-
-
- Natürlich gibt es Szenarien, in denen dieser radikale Ansatz Hürden aufwirft. Wenn Ihr Geschäftsmodell rein auf Retargeting via Facebook-Pixel oder Google Ads Remarketing basiert, kommen Sie um ein Banner kaum herum.
-
-
-
-
-
- Der Verzicht auf invasive Tracker erfordert ein Umdenken im Marketing: Weg von der individuellen Verfolgung, hin zur qualitativen Messung von Conversions. Für B2B-Unternehmen, die auf [Digital Longevity](/blog/digital-longevity-architecture) setzen, ist dies jedoch der einzig nachhaltige Weg.
-
-
-
Der ökonomische Vorteil der Banner-Freiheit
-
-
- Consent-Management-Plattformen (CMPs) sind oft "Performance-Killer". Sie blockieren das Rendering der Seite und verschlechtern die Core Web Vitals massiv. Laut Nielsen Norman Group führen intrusive Banner zu einer drastischen Verschlechterung der User Experience.
-
-
-
-
-
- Indem wir diese Tools eliminieren, verbessern wir nicht nur die UX, sondern sparen auch laufende Lizenzgebühren und minimieren das Abmahnrisiko. Ein [wartungsfreies System](/blog/maintenance-for-headless-systems) ist nicht nur sicherer, sondern langfristig profitabler.
-
-
-
-
-
-
-
Fazit: Befreien Sie Ihre Inhalte
-
-
- Eine Website ohne Banner wirkt sofort aufgeräumter, ehrlicher und wertiger. Es ist ein klares Statement für digitale Professionalität und Respekt gegenüber dem Kunden. In einer Welt voller digitaler Überwachung ist radikale Privatsphäre das ultimative Premium-Merkmal.
-
-
-
- Ich baue Ihnen die Brücke in eine bannerfreie, souveräne Zukunft, in der Technik dem Menschen dient und nicht umgekehrt. Sorgen wir dafür, dass Ihre Inhalte für sich sprechen – ohne erst um Erlaubnis fragen zu müssen.
-
-
-
-
Sind Cookie-Banner wirklich immer Pflicht?
-
- Nein. Nur wenn technisch nicht notwendige Cookies (z. B. für Tracking oder Marketing) gesetzt oder Daten an Drittanbieter in unsichere Drittstaaten übertragen werden, ist eine Einwilligung nötig.
-
-
-
Wie messe ich den Erfolg ohne Cookies?
-
- Durch anonymisierte, aggregierte Analytics-Lösungen, die keine personenbezogenen Daten speichern und somit keine Einwilligung erfordern, während sie dennoch präzise Conversion-Daten liefern.
-
-
-
Verliere ich dadurch wichtige Marketing-Daten?
-
- Im Gegenteil: Da Sie keine Daten durch Banner-Ablehnungen verlieren (die oft bei 40-60% liegen), erhalten Sie eine solidere Datenbasis über die tatsächliche Nutzung Ihrer Website.
-
-
\ No newline at end of file
diff --git a/apps/web/content/blog/why-agencies-are-slow.mdx b/apps/web/content/blog/why-agencies-are-slow.mdx
deleted file mode 100644
index 606c0e2..0000000
--- a/apps/web/content/blog/why-agencies-are-slow.mdx
+++ /dev/null
@@ -1,192 +0,0 @@
----
-title: "Warum B2B-Agenturen für kleine Änderungen Wochen brauchen"
-thumbnail: "/blog/why-agencies-are-slow.png"
-description: "Analysieren Sie die versteckten Kosten bürokratischer Agenturprozesse. Erfahren Sie, wie moderne Architektur und radikale Direktheit Ihren Output vervierfachen."
-date: "2026-02-13"
-tags: ["architecture", "engineering", "business-strategy"]
----
-
-
- Haben Sie sich schon einmal gefragt, warum eine einfache Textänderung oder ein Button-Update bei Ihrer Agentur oft zwei Wochen dauert?
-
-
- Dahinter verbirgt sich kein technisches Rätsel, sondern ein strukturelles Problem: Veraltete Hierarchien und technologischer Overhead, die Innovation im Keim ersticken.
-
-
- Mein Modell radikaler Direktheit bricht diese Flaschenhälse auf. Als Digital Architect eliminiere ich unnötige Schnittstellen und fokussiere mich auf das, was zählt: Ihr fertiges digitales Produkt.
-
-
-
- **TL;DR:** Klassische B2B-Agenturen verbrennen bis zu 35% Produktivität in bürokratischen Prozessen. Durch den Verzicht auf Junior-Entwickler und den Einsatz von Headless-Architekturen lässt sich die Time-to-Market von Wochen auf Tage reduzieren.
-
-
-
- In einer klassischen Full-Service-Agentur landet Ihr Wunsch zuerst beim Account Manager. Dieser gibt ihn an den Projektleiter weiter, der ein Ticket erstellt, welches schließlich einem oft überarbeiteten Junior-Entwickler zugewiesen wird. Jede dieser Stationen ist nicht nur ein potenzieller Flaschenhals, sondern eine massive Fehlerquelle.
-
-
-
-
-
- Informationen gehen verloren, die Umsetzung dauert ewig und am Ende bezahlen Sie für Meetings und Ticket-Management statt für Output. Ich nenne das die "Agentur-Steuer". Während dort noch über Prioritäten diskutiert wird, könnte Ihre neue Lösung bereits live sein.
-
-
-
-
-
-
-
Der systemische Interessenkonflikt
-
-
- Es gibt einen tieferen Grund für die Trägheit: Das Geschäftsmodell. Wenn Agenturen nach abrechenbaren Stunden arbeiten und große Teams finanzieren müssen, fehlt oft der ökonomische Anreiz zur radikalen Vereinfachung. Langsame Prozesse bedeuten oft mehr abrechenbare Projektmanagement-Zeit.
-
-
-
- Laut einer Studie des [McKinsey Global Institute](https://www.mckinsey.com) können ineffiziente Prozesse die organisationale Produktivität um **20-35%** senken. In der Welt der Webentwicklung korreliert dies direkt mit dem [ROI von Clean Code](/blog/clean-code-for-business-value). Wer technische Altlasten anhäuft, zahlt mit der Zeit seiner Markteinführung.
-
-
-
-
-
Handwerk statt Fließband: Mein Boutique-Ansatz
-
-
- In meiner Welt gibt es keine Junioren, an die Arbeit "durchgereicht" wird. Wenn Sie mit mir arbeiten, sprechen Sie direkt mit dem Experten, der die Architektur entwirft und den Code schreibt. Ich betrachte Softwareentwicklung nicht als anonymen Fließband-Job, sondern als digitales Kunsthandwerk.
-
-
-
- Dieser Ansatz erlaubt Flexibilität, die für starre Strukturen unmöglich ist. Wir vermeiden den typischen [Vendor Lock-In](/blog/builder-systems-threaten-independence), indem wir auf eine [Digital Longevity Architektur](/blog/digital-longevity-architecture) setzen, die nicht nur heute funktioniert, sondern auch in fünf Jahren noch wartbar ist.
-
-
-
-
-
-
-
Der Haken an der Sache (Ehrliche Analyse)
-
-
- Natürlich hat radikale Direktheit auch ihren Preis. In einem Boutique-Setup gibt es keine 24/7 Support-Hotline mit 50 Call-Center-Mitarbeitern.
-
-
-
-
- Keine Massenabfertigung: Ich betreue nur eine handvoll Projekte gleichzeitig. Wenn ich voll bin, bin ich voll.
-
-
- Hoher Anspruch an den Kunden: Direktheit erfordert schnelle Entscheidungswege auf Ihrer Seite.
-
-
- Asset statt Kosten: Sie bauen echtes geistiges Eigentum auf, statt eine "Miet-Website" zu führen.
-
-
-
-
Hebel für doppeltes Tempo
-
-
- Um die Zeitfresser zu eliminieren, die laut Gartner bis zu **50% Nacharbeit** durch schlecht definierte Workflows verursachen, nutze ich eine hochmoderne Toolchain:
-
-
-
-
-
-
-
- Ein Blick auf die Realität zeigt: Während traditionelle IT-Serviceprovider laut Gartner rund 1,5 Stunden für eine Routine-Textkorrektur benötigen (inkl. Overhead), zielt mein System auf Zero-Friction Updates ab.
-
-
-
-
-
-
-
Fazit: Echte Geschwindigkeit beginnt dort, wo Hierarchie endet
-
-
- Technologische Exzellenz bedeutet für mich, Ihnen keine Zeit zu stehlen. Wer heute eine Vision hat, sollte sie übermorgen am Markt testen können – nicht erst nach dem dritten Priorisierungs-Meeting der Agentur.
-
-
-
- Wenn Sie bereit sind, technische Altlasten hinter sich zu lassen und in eine Architektur zu investieren, die als echter Business-Accelerator fungiert, sollten wir sprechen. In meinem [Google PageSpeed Guide](/blog/google-pagespeed-guide-warum-ladezeit-ihr-wichtigster-b2b-umsatzhebel-ist) erfahren Sie zudem, warum diese Geschwindigkeit auch Ihr Ranking massiv beeinflusst.
-
-
-
-
-
-
Warum dauert eine Änderung bei Agenturen überhaupt so lange?
- Es liegt oft an manuellen Deployment-Prozessen und mehrstufigen Freigabeketten über Account- und Projektmanager. Jede Schnittstelle addiert Wartezeit und potenzielle Kommunikationsfehler.
-
-
Was ist der Vorteil von Boutique-Architekten gegenüber Großagenturen?
- Sie erhalten direkten Zugriff auf Senior-Expertise ohne den Overhead von Junioren oder Management-Ebenen. Das resultiert in präziserem Code und deutlich schnelleren Iterationszyklen.
-
-
Ist dieser schnelle Ansatz riskanter für die Stabilität?
- Im Gegenteil. Durch moderne CI/CD-Pipelines und automatisierte Tests wird menschliches Versagen minimiert, was die Stabilität im Vergleich zu manuellen Agentur-Prozessen massiv erhöht.
-
-
-
-
-
\ No newline at end of file
diff --git a/apps/web/content/blog/why-no-templates-matter.mdx b/apps/web/content/blog/why-no-templates-matter.mdx
deleted file mode 100644
index 5eba335..0000000
--- a/apps/web/content/blog/why-no-templates-matter.mdx
+++ /dev/null
@@ -1,166 +0,0 @@
----
-title: "Maßwerk statt Massenware: Warum Templates Ihre B2B-Markenidentität verwässern"
-thumbnail: "/blog/why-no-templates-matter.png"
-description: "Erfahren Sie, warum Standard-Templates die Silent Killer Ihrer Conversion sind und wie Bespoke-Architektur digitale Distinktion und messbaren ROI schafft."
-date: "2026-01-28"
-tags: ["design", "strategy", "performance"]
----
-
-
- Vorlagen sind die Fast-Food-Lösung des Web-Designs: Schnell verfügbar, oberflächlich sättigend, aber auf Dauer ungesund für Ihre Marken-Autorität.
-
-
-
- In meiner Arbeit als Digital Architect begegne ich ständig Unternehmen, die in der Beliebigkeit von Standard-Templates versinken und sich wundern, warum ihre digitale Präsenz keine Durchschlagskraft entwickelt.
-
-
-
- Ich zeige Ihnen, warum eine Zero-Template-Architektur nicht nur eine Design-Entscheidung ist, sondern der einzige Weg zu echter digitaler Distinktion und langfristiger Unabhängigkeit.
-
-
-
-
-
-
-
TL;DR: Das Wichtigste in 30 Sekunden
-
-
- Differenzierung: Templates erzeugen eine "digitale Uniform", die den Wiedererkennungswert im B2B-Sektor gegen Null senkt.
-
-
- Performance: Maßgeschneiderte Seiten eliminieren "Unused Code", was laut Google die Time to Interactive (TTI) massiv verbessert.
-
-
- ROI: Bespoke-Lösungen sind digitale Assets (IP), während Templates oft technische Sackgassen mit hohen Anpassungskosten sind.
-
-
-
-
Die Falle der visuellen Gleichschaltung
-
-
- Wenn Sie ein Template nutzen, nutzen Sie die gleiche Basis wie tausende andere Unternehmen weltweit. Das HTTP Archive zeigt, dass der Median heutiger Websites über 1MB JavaScript überträgt – ein Großteil davon ist ungenutzter Ballast aus starren Vorlagen.
-
-
-
- Das Ergebnis ist eine "digitale Uniform", die Ihre Einzigartigkeit im Keim erstickt. Kunden spüren unbewusst, wenn eine Seite "von der Stange" kommt. Studien des Nielsen Norman Group betonen, dass Usability und ein individuelles Design entscheidend für das Vertrauen sind. Ein generisches Design kann dieses Vertrauen schleichend erodieren.
-
-
-
-
-
-
-
- Ich nenne das ästhetische Kapitulation. Wahre Markenbildung braucht Raum zum Atmen und ein Fundament, das nur für Sie gegossen wurde. Forrester Research hat herausgefunden, dass User Experience ein kritischer Differenzierer ist – eine Vorlage kann diese Einzigartigkeit niemals vollumfänglich abbilden.
-
-
-
-
-
- Templates enthalten Code für hunderte Optionen, die Sie nie nutzen werden. Dieser [technische Overhead](/blog/hidden-costs-of-wordpress-plugins) verlangsamt Ihre Seite und verwässert Ihre Botschaft. Lighthouse-Audits markieren ungenutztes CSS und JS regelmäßig als primäre Performance-Killer.
-
-
-
-
-
- In meinem Boutique-Ansatz entwickeln wir jede Komponente von Grund auf. Das Ergebnis ist eine hochpräzise Maschine, die exakt auf Ihre Ziele ausgerichtet ist. Dies korreliert direkt mit den Core Web Vitals: Ein schlankeres System führt zu einem besseren First Input Delay (FID), was die Nutzererfahrung spürbar reaktiver macht.
-
-
-
Technischer Maßanzug vs. Einheitsgröße
-
-
- Templates sind starr. Wenn Ihr Business wächst, wird das [Baukasten-System oft zur Wachstumsbremse](/blog/builder-systems-threaten-independence). Anpassungen am Standard-Code sind oft teurer als ein kompletter Neubau, da man gegen die Architektur der Vorlage arbeiten muss.
-
-
-
-
-
-
-
Der wirtschaftliche Case: Performance als Hebel
-
-
- Daten von Deloitte zeigen, dass eine Verbesserung der Ladezeit um nur 0,1 Sekunden die Conversion-Rate im B2B-Bereich signifikant steigern kann. Ein "Built-First" Ansatz ermöglicht es uns, Performance-Metriken zu erreichen, die mit schweren Templates physikalisch unmöglich sind.
-
-
-
-
-
- Zudem vermeiden Sie den schleichenden Wertverlust Ihrer digitalen Präsenz. Ein eigenes System ist ein [digitales Asset](/blog/digital-longevity-architecture), das in Ihrer Bilanz als geistiges Eigentum (IP) steht, statt nur eine Mietgebühr für eine fremde Plattform zu sein.
-
-
-
Der "Devil's Advocate": Wann ein Template doch reicht
-
-
- Ehrlichkeit gehört zu einer professionellen Architektur-Beratung. Bespoke-Design ist nicht für jeden die richtige Wahl.
-
-
-
-
-
Integrierte Marken-Expertise
-
-
- Wie man Branding und technische Umsetzung erfolgreich verheiratet, zeigt dieser Case Study Einblick:
-
-
-
-
-
-
-
Fazit: Ein Unikat für Ihren Erfolg
-
-
- Hören Sie auf, Ihre Marke in fremde Formen zu pressen. Ein Template ist kein Design, sondern ein Kompromiss. In einem Markt, der immer kompetitiver wird, ist [technische Qualität ein massiver Skalierungsfaktor](/blog/clean-code-for-business-value).
-
-
-
- Lassen wir gemeinsam ein digitales Denkmal setzen, das so unverwechselbar ist wie Ihr unternehmerischer Fingerabdruck.
-
-
-
-
-
-
Ist eine individuelle Website nicht viel teurer als ein Template?
- Initial ist die Investition höher, aber die Total Cost of Ownership (TCO) ist oft geringer, da teure Workarounds und Plugin-Abhängigkeiten entfallen. Zudem transformiert es Marketingausgaben in ein echtes Unternehmensinventar (IP).
-
-
Verschlechtert ein individuelles Design mein Ranking bei Google?
- Im Gegenteil: Durch das Fehlen von Code-Bloat erreichen Bespoke-Websites deutlich bessere Core Web Vitals Scores. Dies führt zu einer besseren Indexierung und bevorzugten Platzierung gegenüber langsamen Vorlagen-Seiten.
-
-
Wie lange dauert die Entwicklung einer Bespoke-Lösung?
- Ein strukturiertes Projekt dauert typischerweise 8 bis 12 Wochen. Durch meinen modularen "Component-First" Ansatz erhalten Sie jedoch schneller ein fertiges System als bei komplexen Anpassungen an widerspenstigen Templates.
-
\ No newline at end of file
diff --git a/apps/web/content/blog/why-websites-break-after-updates.mdx b/apps/web/content/blog/why-websites-break-after-updates.mdx
deleted file mode 100644
index 1646f6c..0000000
--- a/apps/web/content/blog/why-websites-break-after-updates.mdx
+++ /dev/null
@@ -1,159 +0,0 @@
----
-title: "Warum Ihre Website nach Updates nicht mehr funktioniert: Strategien gegen den Software-Zerfall"
-thumbnail: "/blog/why-websites-break-after-updates.png"
-description: "Fehlerhafte Layouts und kaputte Formulare nach Updates kosten B2B-Vertrauen. Erfahren Sie, wie automatisierte Regressionstests und Headless-Architektur Ihre Website stabilisieren."
-date: "2026-02-11"
-tags: ["maintenance", "reliability", "software-engineering"]
----
-
-
- Updates führen bei Standard-Systemen oft zu visuellem Chaos und funktionalen Fehlern. Durch den Einsatz von Automated Testing, Visual Regression und Immutable Deployments eliminieren wir das Risiko von Regressions-Bugs. Stabilität ist kein Zufall, sondern das Ergebnis einer [Clean Code Strategie](/blog/clean-code-for-business-value).
-
-
-
-
-
- "Nach dem letzten Plugin-Update war plötzlich das halbe Layout verschoben."
-
-
- Das ist der Satz, den ich am häufigsten von Neukunden höre, die von klassischen WordPress-Agenturen zu mir wechseln.
-
-
- Für mich ist eine Website ein technisches Präzisionswerkzeug. Ein Werkzeug darf niemals einfach "auseinanderfallen", nur weil eine Komponente aktualisiert wurde. Stabilität ist kein glücklicher Zufall, sondern das Ergebnis eines kompromisslosen Engineering-Systems.
-
-
-
Die Entropie des Webs: Warum Systeme zerfallen
-
-
- Das Internet ist eine extrem dynamische Umgebung. Browser-Updates, neue Sicherheitsstandards und API-Änderungen nagen permanent an der Integrität Ihrer Website. In herkömmlichen monolithischen Systemen sind die Komponenten oft wie ein wackeliger Stapel Lego-Steine angeordnet.
-
-
-
-
-
-
-
- Zieht man einen Stein heraus – etwa durch ein scheinbar harmloses Update eines Drittanbieter-Scripts – gerät das gesamte Konstrukt ins Wanken. Research von Catchpoint Systems legt nahe, dass genau diese Third-Party Updates für ca. 18% aller Performance-Probleme verantwortlich sind, die neue Nutzer direkt abschrecken.
-
-
-
-
-
- Ich baue Architekturen, die diesem Zerfall aktiv widersteht. Dies ist ein Kernaspekt der [Digital Longevity](/blog/digital-longevity-architecture), bei der wir Systeme so konzipieren, dass sie über ein Jahrzehnt wartungsarm bleiben.
-
-
-
Das Sicherheitsnetz: Automatisierung statt Hoffnung
-
-
- Die meisten Fehler entstehen durch manuelle Eingriffe oder das Übersehen von Seiteneffekten. Ein Entwickler ändert das Design auf einer Unterseite und merkt nicht, dass dadurch das Kontaktformular auf einer anderen bricht. Laut Google Developers erleben etwa 20% aller Websites visuelle Regressionen nach Code-Updates.
-
-
-
-
-
-
-
- In meiner Welt gibt es solche Fehler nicht. Ich investiere in automatisierte Wächter. Bevor eine Änderung live geht, prüft eine künstliche Instanz jedes Detail Ihrer gesamten Website. Firmen, die auf umfassende Test-Strategien setzen, reduzieren ihre Bugs nach dem Deployment um bis zu 60%.
-
-
-
-
-
Die "Fortress-Mentalität": Drei Schichten der Sicherheit
-
-
- Sorgen Sie sich nie wieder darum, ob Ihre Seite "das Wochenende überlebt hat". Mein Stabilitäts-System umfasst drei entscheidende Schutzschichten, die weit über das hinausgehen, was [Standard-Baukasten-Systeme](/blog/builder-systems-threaten-independence) leisten können:
-
-
-
-
- Visual Regression Testing: Mein System vergleicht nach jeder Änderung tausende Bildpunkte. Die Maschine sieht Pixel-Abweichungen sofort, die das menschliche Auge übersehen würde.
-
-
- Immutable Deployments: Ich überschreibe niemals Live-Dateien ("In-Place"). Stattdessen wird eine neue Version parallel hochgefahren. Wir können so in Millisekunden auf eine saubere Kopie zurückrollen.
-
-
- Entkoppelte Modul-Logik: Durch eine [Headless-Architektur](/blog/maintenance-for-headless-systems) baue ich in isolierten Komponenten. Eine Änderung an der Blog-Logik kann prinzipiell niemals den Checkout oder die Kontakt-API gefährden.
-
-
-
-
- Laut HTTP Archive führen CI/CD-Pipelines mit automatisierten Tests zu einer 40% schnelleren Deployment-Frequenz. Das bedeutet für Sie: Wir können schneller innovieren, ohne die bestehende Substanz zu gefährden.
-
-
-
-
-
Warum B2B-Entscheider auf Stabilität setzen müssen
-
-
- Instabile Nutzeroberflächen sind kein kosmetisches Problem, sondern ein Conversion-Killer. Die Nielsen Norman Group fand heraus, dass inkonsistente User Experiences zu einem Abfall der Conversion-Rate um 5-10% führen. Nutzer assoziieren eine kaputte Website sofort mit mangelnder Professionalität im Kerngeschäft.
-
-
-
-
-
-
-
Fazit: Ihre digitale Ruhe ist mein Auftrag
-
-
- Souveränität im Netz beginnt bei der Verlässlichkeit der eigenen Werkzeuge. Wenn Sie [technische Altlasten](/blog/slow-loading-costs-customers) mitschleppen, wird jedes Update zum Glücksspiel. Ein professionelles Engineering-Setup verwandelt Ihre Website von einem Sorgenkind in ein robustes digitales Asset, das den Wert Ihres Unternehmens steigert.
-
-
-
-
-
- Lassen wir die Zeit der "kaputten Layouts" ein für alle Mal beenden. Stabilität ist die Basis für Vertrauen. Ihr Erfolg im B2B-Markt verdient dieses solide Fundament.
-
-
-
FAQ
-
-
Warum gehen Websites nach Plugin-Updates oft kaputt?
- Meist kollidieren neue Code-Versionen mit anderen Plugins oder dem Theme, da keine isolierte Testumgebung vorhanden ist. Ohne automatisierte Regressionstests werden diese Seiteneffekte erst bemerkt, wenn Kunden sich beschweren.
-
-
Was ist Visual Regression Testing?
- Dabei vergleicht eine Software Screenshots der Website vor und nach einer Änderung pixelgenau. Jede ungewollte Verschiebung im Layout wird sofort markiert und stoppt den Live-Gang automatisch.
-
-
Lohnt sich der Aufwand für automatisierte Tests finanziell?
- Absolut. Da Fehler in der Produktion laut Capers Jones bis zu 10x teurer zu fixen sind als in der Entwicklung, amortisiert sich das Testing-Setup meist schon nach dem ersten verhinderten Ausfall.
-
\ No newline at end of file
diff --git a/apps/web/content/blog/zero-overhead-agencies.mdx b/apps/web/content/blog/zero-overhead-agencies.mdx
deleted file mode 100644
index 57675ae..0000000
--- a/apps/web/content/blog/zero-overhead-agencies.mdx
+++ /dev/null
@@ -1,110 +0,0 @@
----
-title: "Zero Overhead: Warum klassische Agenturen oft zu langsam (und zu teuer) sind"
-thumbnail: "/blog/zero-overhead-agencies.png"
-description: "Projektmanager, Account Manager, Junior Designer – bei klassischen Agenturen zahlen Sie oft den Wasserkopf mit. Wie ein Lean-Ansatz bessere und schnellere Ergebnisse liefert."
-date: "2026-05-06"
-tags: ["management", "strategy", "efficiency"]
----
-
-
- Sie kennen den Ablauf: Ein Kick-off-Meeting mit fünf Personen. Ein Account Manager, ein Projektmanager, ein Designer, ein Entwickler und vielleicht noch ein Stratege.
-
-
- Was sich auf dem Papier nach geballter Kompetenz anhört, ist in der Realität oft der Startschuss für den Stille-Post-Effekt. Ressourcen werden verschwendet, Deadlines reißen und Budgets explodieren.
-
-
- Die Alternative ist "Lean Engineering". Ein Ansatz, der Hierarchien eliminiert, technische Exzellenz in den Vordergrund stellt und den administrativen Wasserkopf radikal abschneidet.
-
-
-
-
-
Der Preis des Wasserkopfs
-
-
- Klassische Agenturen haben einen hohen administrativen Overhead. Großraumbüros in Top-Lagen, repräsentative Empfangsbereiche und Gehälter für Mitarbeiter, die keinen einzigen direkten Beitrag zu Ihrem Produkt leisten (Projektmanagement, HR, Sales). All das muss über Ihren Stundensatz finanziert werden.
-
-
-
- Das Problem dabei ist nicht nur der aufgeblähte Preis, sondern die **Geschwindigkeit**. Wenn Sie eine einfache inhaltliche oder funktionale Anpassung anfordern, geht die E-Mail an den Projektmanager. Dieser schreibt ein Ticket für den Designer. Der Designer macht einen Entwurf. Der Projektmanager schickt Ihnen den Entwurf. Sie geben Feedback. Das Ticket geht zurück zum Designer, dann zum Entwickler, dann in die QA, dann wieder zu Ihnen.
-
-
-
-
-
Der Lean-Ansatz: Ein Ansprechpartner, volle Verantwortung
-
-
- Der Gegensatz dazu ist der Lean-Ansatz. Als unabhängiger Digital Architect bin ich Ihr einziger Ansprechpartner. Ich analysiere Ihre Business-Ziele, entwerfe die Systemarchitektur, designe das Interface und schreibe den Code.
-
-
-
-
- graph TD
- A[Kunde] --> B[Projektmanager]
- B --> C[Designer]
- B --> D[Entwickler]
- B --> E[Copywriter]
-
- F[Kunde] --> G[Marc Mintel (Architect)]
- G --> H[Direktes Ergebnis (Code/Design)]
-
- style A fill:#f87171,stroke:#333
- style F fill:#4ade80,stroke:#333
-
-
-
-
- Dieser direkte Weg reduziert Missverständnisse auf null. Wenn wir in einem Call über eine neue Funktion sprechen, weiß ich sofort, wie diese technisch im Hintergrund umsetzbar ist und ob sie in den [strategischen Festpreis](/blog/fixed-price-digital-projects) passt. Es gibt keine unrealistischen Versprechungen im Vertrieb, die die Technik später mühsam ausbaden muss.
-
-
-
Weniger ist technologisch schneller
-
-
- Ein oft unterschätzter Faktor ist die technologische Reibung innerhalb großer Teams. In Agenturen müssen Technologien oft so gewählt werden, dass auch der Junior-Entwickler oder der Praktikant sie versteht. Es werden schwere, veraltete Frameworks oder Baukasten-CMS-Systeme (wie WordPress) eingesetzt, weil sie der kleinste gemeinsame Nenner sind.
-
-
-
- Wenn man den Overhead eliminiert, kann man auf [hochperformante, moderne Stacks (Jamstack, Next.js)](/blog/digital-longevity-architecture) setzen. Diese wären für ein heterogenes Team oft zu komplex im Setup, können von einem Senior-Entwickler aber in einem Bruchteil der Zeit fehlerfrei und in industrieller Qualität gebaut werden.
-
-
-
-
-
-
-
Agile vs. Waterfall: Warum Agenturen oft stecken bleiben
-
-
- Viele Agenturen behaupten, agil zu arbeiten, praktizieren aber eigentlich einen "Wasserfall-Prozess" in Sprints. Das Design wird komplett finalisiert (und abgerechnet), bevor die erste Zeile Code geschrieben wird. Wenn in der Entwicklung auffällt, dass eine Interaktion technisch unsauber ist, fängt der Kreislauf von vorne an.
-
-
-
- Im Zero-Overhead-Modell verschmelzen Design und Entwicklung. Ich gestalte oft direkt im Code. Das bedeutet, wir können echte Klick-Prototypen im Browser testen, statt statische Bilder anzustarren. Das spart nicht nur Wochen an Projektzeit, sondern führt zu digitalen Produkten, die sich von Grund auf flüssiger anfühlen.
-
-
-
Wann eine Agentur Sinn macht
-
-
- Um fair zu bleiben: Es gibt Projekte, für die eine Agentur zwingend notwendig ist. Wenn Sie eine globale 360-Grad-Kampagne planen, physische Plakatwände buchen, TV-Spots produzieren und 50 verschiedene Landingpages gleichzeitig in 10 Sprachen ausrollen müssen, brauchen Sie schlichtweg Manpower.
-
-
-
- Aber für 90% der B2B-Unternehmen, die eine hochprofessionelle, blitzschnelle und zukunftssichere Plattform brauchen, um digitale Dominanz auszustrahlen und Leads zu generieren? Dafür ist eine Agentur meistens Overkill – und ein massiver Rendite-Killer.
-
-
-
-
-
-
Was passiert, wenn der alleinige Entwickler ausfällt?
-
- Das ist eine berechtigte Frage (der sogenannte Bus-Faktor). Die Antwort liegt in der Code-Qualität. Durch strikte, industrieweite Standards, extrem saubere Dokumentation und den Verzicht auf obskure proprietäre Plugins kann sich jeder erfahrene React/Next.js-Entwickler innerhalb von Stunden in meine Architektur einarbeiten.
-
-
-
Fehlt ohne Agentur nicht die strategische Beratung?
-
- Ganz im Gegenteil. Als Digital Architect übernehme ich genau diesen strategischen Part. Da ich nicht versuchen muss, meine 20-köpfige Design-Abteilung auszulasten, ist meine Beratung 100% objektiv und auf Ihren geschäftlichen Erfolg fokussiert, nicht auf meine interne Auslastung.
-
-
-
Können große Projekte überhaupt alleine gestemmt werden?
'),setTimeout(function(){r.addClass("processing")},50),o.push({name:"action",value:"nectar_ajax_add_to_cart"},{name:"add-to-cart",value:n.state.productID}),t.ajax({type:"POST",url:e.nectarLove.ajaxurl,data:o,cache:!1,success:function(e){setTimeout(function(){n.state.processing=!1,r.removeClass("processing"),r.find(".loading-wrap").remove()},300),e&&e.fragments&&(t("body").trigger("added_to_cart",[e.fragments,e.cart_hash]),e.notices&&e.notices.length>0&&setTimeout(function(){n.addNotices(e.notices)},100),"quickview"===n.state.type&&t(".nectar-quick-view-box .close").trigger("click"))}})):console.log("Error: no product ID found.")}},pn.prototype.setup=function(){this.$container=t(''),t("#search-outer").append(t('