1import { NextResponse } from "next/server"
2import type { NextRequest } from "next/server"
3import { getToken } from "next-auth/jwt"
4 
5export async function middleware(request: NextRequest) {
6  const token = await getToken({ req: request })
7  if (!token && isProtectedRoute(request)) {
8    return NextResponse.redirect(new URL("/login", request.url))
9  }
10  return NextResponse.next()
11}
12 
13export const config = {
14  matcher: ["/dashboard/:path*", "/api/:path*"],
15}
16 
17// lib/db.ts
18import { PrismaClient } from "@prisma/client"
19 
20const globalForPrisma = globalThis as { prisma?: PrismaClient }
21export const db = globalForPrisma.prisma ?? new PrismaClient()
22 
23if (process.env.NODE_ENV !== "production") {
24  globalForPrisma.prisma = db
25}
26 
27// components/Card.tsx
28interface CardProps {
29  title: string
30  description: string
31  href: string
32  icon?: React.ReactNode
33}
34 
35export function Card({ title, description, href, icon }: CardProps) {
36  return (
37    <Link href={href} className={cn(cardBase, cardHover)}>
38      {icon && <div className="card-icon">{icon}</div>}
39      <h3 className="font-semibold text-lg">{title}</h3>
40      <p className="text-zinc-400 text-sm">{description}</p>
41    </Link>
42  )
43}
44 
45// app/api/projects/route.ts
46export async function GET(request: Request) {
47  const { searchParams } = new URL(request.url)
48  const page = parseInt(searchParams.get("page") ?? "1")
49  const projects = await db.project.findMany({
50    take: 12,
51    skip: (page - 1) * 12,
52    orderBy: { updatedAt: "desc" },
53    include: { author: true, tags: true },
54  })
55  return Response.json({ projects, page })
56}
57 
58export async function POST(request: Request) {
59  const body = await request.json()
60  const validated = projectSchema.parse(body)
61  const project = await db.project.create({
62    data: { ...validated, authorId: session.user.id },
63  })
64  return Response.json(project, { status: 201 })
65}
66 
67// hooks/useDebounce.ts
68export function useDebounce<T>(value: T, delay: number): T {
69  const [debouncedValue, setDebouncedValue] = useState<T>(value)
70  useEffect(() => {
71    const timer = setTimeout(() => setDebouncedValue(value), delay)
72    return () => clearTimeout(timer)
73  }, [value, delay])
74  return debouncedValue
75}
76 
77// hooks/useLocalStorage.ts
78export function useLocalStorage<T>(key: string, initial: T) {
79  const [value, setValue] = useState<T>(() => {
80    if (typeof window === "undefined") return initial
81    const stored = localStorage.getItem(key)
82    return stored ? JSON.parse(stored) : initial
83  })
84  const setStored = (val: T) => {
85    setValue(val)
86    localStorage.setItem(key, JSON.stringify(val))
87  }
88  return [value, setStored] as const
89}
90 
91// app/dashboard/page.tsx
92export default async function DashboardPage() {
93  const session = await getServerSession(authOptions)
94  if (!session) redirect("/login")
95  const projects = await db.project.findMany({
96    where: { authorId: session.user.id },
97    orderBy: { updatedAt: "desc" },
98  })
99  return (
100    <main className="container mx-auto py-8">
101      <h1 className="text-3xl font-bold mb-8">Dashboard</h1>
102      <ProjectGrid projects={projects} />
103    </main>
104  )
105}
106 
107// lib/auth.ts
108export const authOptions: NextAuthOptions = {
109  adapter: PrismaAdapter(db),
110  providers: [
111    GitHubProvider({
112      clientId: process.env.GITHUB_ID!,
113      clientSecret: process.env.GITHUB_SECRET!,
114    }),
115    GoogleProvider({
116      clientId: process.env.GOOGLE_ID!,
117      clientSecret: process.env.GOOGLE_SECRET!,
118    }),
119  ],
120  callbacks: {
121    session({ session, user }) {
122      session.user.id = user.id
123      return session
124    },
125  },
126}
1import { NextResponse } from "next/server"
2import type { NextRequest } from "next/server"
3import { getToken } from "next-auth/jwt"
4 
5export async function middleware(request: NextRequest) {
6  const token = await getToken({ req: request })
7  if (!token && isProtectedRoute(request)) {
8    return NextResponse.redirect(new URL("/login", request.url))
9  }
10  return NextResponse.next()
11}
12 
13export const config = {
14  matcher: ["/dashboard/:path*", "/api/:path*"],
15}
16 
17// lib/db.ts
18import { PrismaClient } from "@prisma/client"
19 
20const globalForPrisma = globalThis as { prisma?: PrismaClient }
21export const db = globalForPrisma.prisma ?? new PrismaClient()
22 
23if (process.env.NODE_ENV !== "production") {
24  globalForPrisma.prisma = db
25}
26 
27// components/Card.tsx
28interface CardProps {
29  title: string
30  description: string
31  href: string
32  icon?: React.ReactNode
33}
34 
35export function Card({ title, description, href, icon }: CardProps) {
36  return (
37    <Link href={href} className={cn(cardBase, cardHover)}>
38      {icon && <div className="card-icon">{icon}</div>}
39      <h3 className="font-semibold text-lg">{title}</h3>
40      <p className="text-zinc-400 text-sm">{description}</p>
41    </Link>
42  )
43}
44 
45// app/api/projects/route.ts
46export async function GET(request: Request) {
47  const { searchParams } = new URL(request.url)
48  const page = parseInt(searchParams.get("page") ?? "1")
49  const projects = await db.project.findMany({
50    take: 12,
51    skip: (page - 1) * 12,
52    orderBy: { updatedAt: "desc" },
53    include: { author: true, tags: true },
54  })
55  return Response.json({ projects, page })
56}
57 
58export async function POST(request: Request) {
59  const body = await request.json()
60  const validated = projectSchema.parse(body)
61  const project = await db.project.create({
62    data: { ...validated, authorId: session.user.id },
63  })
64  return Response.json(project, { status: 201 })
65}
66 
67// hooks/useDebounce.ts
68export function useDebounce<T>(value: T, delay: number): T {
69  const [debouncedValue, setDebouncedValue] = useState<T>(value)
70  useEffect(() => {
71    const timer = setTimeout(() => setDebouncedValue(value), delay)
72    return () => clearTimeout(timer)
73  }, [value, delay])
74  return debouncedValue
75}
76 
77// hooks/useLocalStorage.ts
78export function useLocalStorage<T>(key: string, initial: T) {
79  const [value, setValue] = useState<T>(() => {
80    if (typeof window === "undefined") return initial
81    const stored = localStorage.getItem(key)
82    return stored ? JSON.parse(stored) : initial
83  })
84  const setStored = (val: T) => {
85    setValue(val)
86    localStorage.setItem(key, JSON.stringify(val))
87  }
88  return [value, setStored] as const
89}
90 
91// app/dashboard/page.tsx
92export default async function DashboardPage() {
93  const session = await getServerSession(authOptions)
94  if (!session) redirect("/login")
95  const projects = await db.project.findMany({
96    where: { authorId: session.user.id },
97    orderBy: { updatedAt: "desc" },
98  })
99  return (
100    <main className="container mx-auto py-8">
101      <h1 className="text-3xl font-bold mb-8">Dashboard</h1>
102      <ProjectGrid projects={projects} />
103    </main>
104  )
105}
106 
107// lib/auth.ts
108export const authOptions: NextAuthOptions = {
109  adapter: PrismaAdapter(db),
110  providers: [
111    GitHubProvider({
112      clientId: process.env.GITHUB_ID!,
113      clientSecret: process.env.GITHUB_SECRET!,
114    }),
115    GoogleProvider({
116      clientId: process.env.GOOGLE_ID!,
117      clientSecret: process.env.GOOGLE_SECRET!,
118    }),
119  ],
120  callbacks: {
121    session({ session, user }) {
122      session.user.id = user.id
123      return session
124    },
125  },
126}

1import { NextResponse } from "next/server"
2import type { NextRequest } from "next/server"
3import { getToken } from "next-auth/jwt"
4 
5export async function middleware(request: NextRequest) {
6  const token = await getToken({ req: request })
7  if (!token && isProtectedRoute(request)) {
8    return NextResponse.redirect(new URL("/login", request.url))
9  }
10  return NextResponse.next()
11}
12 
13export const config = {
14  matcher: ["/dashboard/:path*", "/api/:path*"],
15}
16 
17// lib/db.ts
18import { PrismaClient } from "@prisma/client"
19 
20const globalForPrisma = globalThis as { prisma?: PrismaClient }
21export const db = globalForPrisma.prisma ?? new PrismaClient()
22 
23if (process.env.NODE_ENV !== "production") {
24  globalForPrisma.prisma = db
25}
26 
27// components/Card.tsx
28interface CardProps {
29  title: string
30  description: string
31  href: string
32  icon?: React.ReactNode
33}
34 
35export function Card({ title, description, href, icon }: CardProps) {
36  return (
37    <Link href={href} className={cn(cardBase, cardHover)}>
38      {icon && <div className="card-icon">{icon}</div>}
39      <h3 className="font-semibold text-lg">{title}</h3>
40      <p className="text-zinc-400 text-sm">{description}</p>
41    </Link>
42  )
43}
44 
45// app/api/projects/route.ts
46export async function GET(request: Request) {
47  const { searchParams } = new URL(request.url)
48  const page = parseInt(searchParams.get("page") ?? "1")
49  const projects = await db.project.findMany({
50    take: 12,
51    skip: (page - 1) * 12,
52    orderBy: { updatedAt: "desc" },
53    include: { author: true, tags: true },
54  })
55  return Response.json({ projects, page })
56}
57 
58export async function POST(request: Request) {
59  const body = await request.json()
60  const validated = projectSchema.parse(body)
61  const project = await db.project.create({
62    data: { ...validated, authorId: session.user.id },
63  })
64  return Response.json(project, { status: 201 })
65}
66 
67// hooks/useDebounce.ts
68export function useDebounce<T>(value: T, delay: number): T {
69  const [debouncedValue, setDebouncedValue] = useState<T>(value)
70  useEffect(() => {
71    const timer = setTimeout(() => setDebouncedValue(value), delay)
72    return () => clearTimeout(timer)
73  }, [value, delay])
74  return debouncedValue
75}
76 
77// hooks/useLocalStorage.ts
78export function useLocalStorage<T>(key: string, initial: T) {
79  const [value, setValue] = useState<T>(() => {
80    if (typeof window === "undefined") return initial
81    const stored = localStorage.getItem(key)
82    return stored ? JSON.parse(stored) : initial
83  })
84  const setStored = (val: T) => {
85    setValue(val)
86    localStorage.setItem(key, JSON.stringify(val))
87  }
88  return [value, setStored] as const
89}
90 
91// app/dashboard/page.tsx
92export default async function DashboardPage() {
93  const session = await getServerSession(authOptions)
94  if (!session) redirect("/login")
95  const projects = await db.project.findMany({
96    where: { authorId: session.user.id },
97    orderBy: { updatedAt: "desc" },
98  })
99  return (
100    <main className="container mx-auto py-8">
101      <h1 className="text-3xl font-bold mb-8">Dashboard</h1>
102      <ProjectGrid projects={projects} />
103    </main>
104  )
105}
106 
107// lib/auth.ts
108export const authOptions: NextAuthOptions = {
109  adapter: PrismaAdapter(db),
110  providers: [
111    GitHubProvider({
112      clientId: process.env.GITHUB_ID!,
113      clientSecret: process.env.GITHUB_SECRET!,
114    }),
115    GoogleProvider({
116      clientId: process.env.GOOGLE_ID!,
117      clientSecret: process.env.GOOGLE_SECRET!,
118    }),
119  ],
120  callbacks: {
121    session({ session, user }) {
122      session.user.id = user.id
123      return session
124    },
125  },
126}
1import { NextResponse } from "next/server"
2import type { NextRequest } from "next/server"
3import { getToken } from "next-auth/jwt"
4 
5export async function middleware(request: NextRequest) {
6  const token = await getToken({ req: request })
7  if (!token && isProtectedRoute(request)) {
8    return NextResponse.redirect(new URL("/login", request.url))
9  }
10  return NextResponse.next()
11}
12 
13export const config = {
14  matcher: ["/dashboard/:path*", "/api/:path*"],
15}
16 
17// lib/db.ts
18import { PrismaClient } from "@prisma/client"
19 
20const globalForPrisma = globalThis as { prisma?: PrismaClient }
21export const db = globalForPrisma.prisma ?? new PrismaClient()
22 
23if (process.env.NODE_ENV !== "production") {
24  globalForPrisma.prisma = db
25}
26 
27// components/Card.tsx
28interface CardProps {
29  title: string
30  description: string
31  href: string
32  icon?: React.ReactNode
33}
34 
35export function Card({ title, description, href, icon }: CardProps) {
36  return (
37    <Link href={href} className={cn(cardBase, cardHover)}>
38      {icon && <div className="card-icon">{icon}</div>}
39      <h3 className="font-semibold text-lg">{title}</h3>
40      <p className="text-zinc-400 text-sm">{description}</p>
41    </Link>
42  )
43}
44 
45// app/api/projects/route.ts
46export async function GET(request: Request) {
47  const { searchParams } = new URL(request.url)
48  const page = parseInt(searchParams.get("page") ?? "1")
49  const projects = await db.project.findMany({
50    take: 12,
51    skip: (page - 1) * 12,
52    orderBy: { updatedAt: "desc" },
53    include: { author: true, tags: true },
54  })
55  return Response.json({ projects, page })
56}
57 
58export async function POST(request: Request) {
59  const body = await request.json()
60  const validated = projectSchema.parse(body)
61  const project = await db.project.create({
62    data: { ...validated, authorId: session.user.id },
63  })
64  return Response.json(project, { status: 201 })
65}
66 
67// hooks/useDebounce.ts
68export function useDebounce<T>(value: T, delay: number): T {
69  const [debouncedValue, setDebouncedValue] = useState<T>(value)
70  useEffect(() => {
71    const timer = setTimeout(() => setDebouncedValue(value), delay)
72    return () => clearTimeout(timer)
73  }, [value, delay])
74  return debouncedValue
75}
76 
77// hooks/useLocalStorage.ts
78export function useLocalStorage<T>(key: string, initial: T) {
79  const [value, setValue] = useState<T>(() => {
80    if (typeof window === "undefined") return initial
81    const stored = localStorage.getItem(key)
82    return stored ? JSON.parse(stored) : initial
83  })
84  const setStored = (val: T) => {
85    setValue(val)
86    localStorage.setItem(key, JSON.stringify(val))
87  }
88  return [value, setStored] as const
89}
90 
91// app/dashboard/page.tsx
92export default async function DashboardPage() {
93  const session = await getServerSession(authOptions)
94  if (!session) redirect("/login")
95  const projects = await db.project.findMany({
96    where: { authorId: session.user.id },
97    orderBy: { updatedAt: "desc" },
98  })
99  return (
100    <main className="container mx-auto py-8">
101      <h1 className="text-3xl font-bold mb-8">Dashboard</h1>
102      <ProjectGrid projects={projects} />
103    </main>
104  )
105}
106 
107// lib/auth.ts
108export const authOptions: NextAuthOptions = {
109  adapter: PrismaAdapter(db),
110  providers: [
111    GitHubProvider({
112      clientId: process.env.GITHUB_ID!,
113      clientSecret: process.env.GITHUB_SECRET!,
114    }),
115    GoogleProvider({
116      clientId: process.env.GOOGLE_ID!,
117      clientSecret: process.env.GOOGLE_SECRET!,
118    }),
119  ],
120  callbacks: {
121    session({ session, user }) {
122      session.user.id = user.id
123      return session
124    },
125  },
126}

Verfügbar für neue Projekte·ab 150 €

dispine.de

Wir entwickeln moderne Websites,
die Kunden gewinnen.

Premium Webseiten für Unternehmen, Startups und Personal Brands.
Maßgeschneidert. Performant. Unvergesslich.

Kostenloses Erstgespräch Projekte ansehen

Agentur

5.000 €+

Dispine ab

150 €

Du sparst

bis zu 97 %

50+

Projekte abgeschlossen

100%

Kundenzufriedenheit

10+ J.

Erfahrung

Lighthouse Score

Der direkte Vergleich

Dispine vs. Klassische Agentur

Gleiche Qualität. Deutlich weniger Kosten. Kein Overhead, keine Zwischenstufen — nur Ergebnisse.

Jetzt kostenlos anfragen

Dispine

Klassische Agentur

Preis

Ab 150 € – fair & transparent

5.000 € – 50.000 €+

Lieferzeit

Tage, nicht Monate

3–6+ Monate Wartezeit

Ansprechpartner

Direkt mit dem Entwickler

PM → Designer → Dev → QA …

Qualität

Lighthouse 99 · maßgeschneidert

Oft Templates, unklare Standards

Kommunikation

Antwort in 24h garantiert

Ticket-System, lange Wartezeiten

Vorschau / Mockup

Kostenlose Vorschau vorab

Erst zahlen, dann sehen

Support nach Launch

30 Tage kostenlos inklusive

Teurer Wartungsvertrag nötig

Bis zu 97 % günstiger als eine klassische Agentur.

Mit dem gleichen — oft besseren — Ergebnis. Überzeugt euch selbst.

Kostenloses Gespräch buchen

ReactNext.jsTypeScriptNode.jsTailwindCSSMongoDBFirebasePostgreSQLGraphQLDockerPrismaStripeVercelFramerAWSReactNext.jsTypeScriptNode.jsTailwindCSSMongoDBFirebasePostgreSQLGraphQLDockerPrismaStripeVercelFramerAWS

< 100ms

Ladezeit

Core Web Vitals optimiert

100%

Mobile Optimized

Perfekt auf allen Geräten

SEO

Ready

Von Tag 1 an sichtbar

Services

Was wir für euch entwickeln

Von der Idee bis zum Launch – alles aus einer Hand, ohne Kompromisse.

Mehr erfahren

Business Websites

Repräsentative Unternehmenswebsites, die Vertrauen aufbauen und qualifizierte Kunden überzeugen.

Next.jsCMSSEO

Mehr erfahren

Landingpages

Conversion-optimierte Landingpages, die aus Besuchern Kunden machen – messbar und skalierbar.

A/B TestingAnalyticsFunnels

Mehr erfahren

E-Commerce

Hochperformante Online-Shops mit reibungsloser Kauferfahrung, Payment-Integration und Inventory.

StripeShopifyWooCommerce

Mehr erfahren

Web Apps

Maßgeschneiderte Webanwendungen, die komplexe Prozesse automatisieren und digitalisieren.

ReactNode.jsAPIs

Mehr erfahren

UI/UX Design

Durchdachte Interfaces, die begeistern – von der ersten Wireframe bis zum Pixel-perfect Design.

FigmaDesign SystemsPrototypen

Mehr erfahren

SEO Optimierung

Technische SEO und Content-Strategie für bessere Rankings und mehr organischen Traffic.

Core Web VitalsSchemaLinkbuilding

Mehr erfahren

Performance Audit

Lighthouse Score auf 95+ bringen – Ladezeit, Rendering und Bundle Size professionell optimieren.

LighthouseWebPCaching

Eigene Idee?

Wir realisieren auch individuelle Projekte. Lass uns reden.

Anfrage stellen

Portfolio

Ausgewählte Projekte

Jedes Projekt mit einem klaren Ziel: messbare Ergebnisse für den Kunden.

Start

Kostenlos starten →

Stripe

SSO

API

SaaS Website

Projekt ansehen

TechStartup Pro

Moderne SaaS-Landingpage mit Conversion-Optimierung, interaktiven Feature-Demos und Stripe Integration.

Next.jsFramer MotionStripe

E-Commerce

Projekt ansehen

UrbanShop

Hochperformanter Online-Shop mit über 10.000 Produkten, Echtzeit-Suche und automatisiertem Inventory.

ReactNode.jsMongoDB

2.4k

Users

98%

Uptime

14ms

Latency

LIVE

Web Application

Projekt ansehen

FlowApp Dashboard

Komplexes Analytics-Dashboard mit Echtzeit-Daten, Custom Charts und Role-based Access Control.

TypeScriptGraphQLPostgreSQL

Award 2024

GSAP

Creative Website

Projekt ansehen

Luminary Agency

Award-würdige Kreativagentur-Website mit immersiven Scroll-Animationen und 3D-Elementen.

Next.jsGSAPThree.js

75%

Ziel

8.432

Schritte

1.840

Kalorien

72 BPM

Progressive Web App

Projekt ansehen

HealthTrack PWA

Health-Tracking App mit Offline-Funktionalität, Push-Notifications und biometrischer Authentifizierung.

ReactPWAFirebase

Kanzlei

Leistungen

Team

Kontakt

Gesellschaftsrecht

Steuerrecht

Compliance

DSGVO

ISO 27001

DE/EN

Corporate Website

Projekt ansehen

LexCorp Legal

Professioneller Webauftritt für eine internationale Kanzlei – mehrsprachig, DSGVO-konform, barrierefrei.

Next.jsSanity CMSi18n

Warum Dispine?

Warum ihr mit uns arbeiten solltet

Wir sind kein Tool, kein Template-Generator und keine Agentur mit 50 Zwischenstufen. Wir sind ein Team, das sich wirklich für euren Erfolg einsetzt.

100%

Fokus auf euer Projekt

24h

Reaktionszeit garantiert

“Wir setzen uns direkt ans Projekt – damit ihr so schnell wie möglich live geht.”

— Das Dispine Team

IN-HOUSE TEAM

Mehr erfahren

Kein Outsourcing

Ihr habt feste Ansprechpartner in unserem Team – keine externen Freelancer, keine Weiterleitung. Euer Projekt bleibt bei uns.

Design

Code

SEO

Launch

EIN TEAM · EIN ANSPRECHPARTNER · EIN PROZESS

Mehr erfahren

Alles aus einer Hand

Design, Entwicklung, SEO und Launch – wir übernehmen den kompletten Prozess. Ihr müsst nichts koordinieren, wir kümmern uns um alles.

150€

individuell

Kein Verstecktes

Festpreis vereinbart

Individuell kalkuliert

Mehr erfahren

Faire Festpreise

Keine versteckten Kosten, keine bösen Überraschungen. Wir klären den Preis vorab transparent – ab 150 € individuell nach euren Wünschen.

JUNI 2025

LIEFERUNG IN WOCHEN

Mehr erfahren

Schnelle Lieferzeiten

Wir setzen uns direkt ans Projekt – keine langen Vorgespräche, kein Warten. Euer Start ist unser Start.

Agentur

5.000€+

lange Wartezeit

Dispine

ab 150€

gleiche Qualität

Premium-Qualität zum fairen Preis

Mehr erfahren

Premium auf Agenturniveau

Wir liefern Qualität, die ihr sonst nur bei teuren Agenturen bekommt – zu einem Preis, der fair und realistisch ist.

Habt ihr Zeit für ein Update?

Natürlich! Gleich erledigt

Perfekt, danke!

30 TAGE AFTER-LAUNCH SUPPORT

Mehr erfahren

Support nach dem Launch

Mit uns hört die Zusammenarbeit nicht beim Launch auf. Wir bleiben euer Partner – für Updates, Anpassungen und Wachstum.

Unsere Stärken

Der Unterschied, der zählt

Kein Copy-Paste. Keine Templates. Echte Handwerksarbeit, die Ergebnisse liefert.

50+

Projekte

3 J.

Erfahrung

Lighthouse

Sofort

Projektstart

Schnelle Kommunikation

Wir setzen uns direkt an euer Projekt. Klare Updates, transparent und ohne Überraschungen.

Modernstes Design

Inspiriert von Apple, Stripe und Linear. Designs, die 2025 und darüber hinaus funktionieren.

Performance Fokus

Lighthouse Score 95+ garantiert. Jede Millisekunde zählt – für Rankings und Conversions.

SEO Optimierung

Technisch sauberes Fundament, strukturierte Daten und optimale Core Web Vitals für bessere Rankings.

Individuelle Entwicklung

Kein Baukastensystem. Jede Zeile Code ist für euer spezifisches Projekt und eure Ziele geschrieben.

Keine Templates

100% Custom Design. Eure Website ist einzigartig – nicht das Skin über einem Fremden-Framework.

Prozess

So arbeiten wir zusammen

Vier klare Schritte – vom ersten Gespräch bis zum erfolgreichen Launch.

Hallo! Wir brauchen eine neue Website für unser Startup

Super! Lasst uns das besprechen. Wann passt ein kurzes Gespräch?

Direkt verfügbar

STEP 01

Anfrage

Kontaktiert uns mit eurer Idee – unser Team setzt sich direkt ans Projekt und bespricht alles Weitere kostenlos und unverbindlich.

Kostenlos via Zoom, Telefon oder E-Mail

Schnell bereit

Konzept fertig

STEP 02

Konzept

Wir erarbeiten ein maßgeschneidertes Konzept: Zieldefinition, Wireframes, Designdirektion und ein transparenter Kostenrahmen.

Wireframes, Sitemap und Projektplan – zügig und ohne lange Wartezeit

dispine — zsh

$ git commit -m 'feat: hero section'

✓ 3 files changed

$ npm run build

▲ Next.js 14.2 compiled

✓ Ready in 1.3s

Fortschritt78%

LIVE Preview

STEP 03

Entwicklung

Wir entwickeln euer Projekt mit regelmäßigen Updates und Live-Previews. Ihr habt jederzeit Einblick in den aktuellen Stand.

Wöchentliche Updates + Live Staging-Umgebung

Domain verbunden

SSL Zertifikat aktiv

Performance geprüft

Website ist LIVE

STEP 04

Launch

Nach finaler Abnahme wird eure Website live gestellt – inklusive technischer Übergabe, Training und 30 Tagen Support.

Deploy, Domain-Setup und 30 Tage After-Launch Support

Testimonials

Was Kunden sagen

Echte Ergebnisse für echte Unternehmen.

5.0/ 50+ Bewertungen

“Die Zusammenarbeit war absolut professionell. Die Website übertrifft alle unsere Erwartungen – schnell, modern und wunderschön. Unsere Leads haben sich verdoppelt.”

Max Müller

CEO · TechGmbH

“Endlich ein Entwickler, der wirklich zuhört. Das Ergebnis spricht für sich – unsere Conversion Rate ist um 40% gestiegen. Absolut empfehlenswert.”

Sarah Schmidt

Marketing Direktorin · StartupX

“Pünktlich, kommunikativ, und das beste Design, das ich je gesehen habe. Hat unsere Konkurrenz weit überholt. Werden definitiv wieder buchen.”

Thomas Weber

Gründer · E-Commerce Plus

“Das Team hat sich direkt ans Projekt gesetzt – und wir haben eine Website bekommen, auf die wir stolz sind. Der Prozess war klar, die Kommunikation top und das Ergebnis überragend.”

Julia Bauer

Brand Managerin · Luminary Studios

“Professionelle Abwicklung von A bis Z. Lighthouse Score von 98 – unsere Kunden fragen immer, wer die Seite gemacht hat.”

Klaus Hoffmann

Steuerberater · Kanzlei Hoffmann

“Wir brauchten eine komplexe Web-App mit Dashboard und API-Anbindung. Sauber umgesetzt, on time, on budget. Exzellent.”

Mia Lange

CTO · FlowData AG

Jetzt verfügbar

Lass uns deine Website auf das nächste Level bringen.

Einfach Formular ausfüllen – unser Team setzt sich direkt an euer Projekt und klärt alles Weitere. Kostenlos und unverbindlich.

Unser Team kümmert sich direkt um eure Anfrage

Projekte ab 150 € – individuell nach Wunsch

Unser Team kümmert sich um alles

Eure Daten werden nicht weitergegeben

hallo@dispine.de·GitHub·LinkedIn

Anfrage stellen

Alle mit * markierten Felder sind Pflichtfelder.

Wir entwickeln moderne Websites, die Kunden gewinnen.

Dispine vs. Klassische Agentur

Was wir für euch entwickeln

Business Websites

Landingpages

E-Commerce

Web Apps

UI/UX Design

SEO Optimierung

Performance Audit

Eigene Idee?

Ausgewählte Projekte

TechStartup Pro

UrbanShop

FlowApp Dashboard

Luminary Agency

HealthTrack PWA

LexCorp Legal

Warum ihr mit uns arbeiten solltet

Kein Outsourcing

Alles aus einer Hand

Faire Festpreise

Schnelle Lieferzeiten

Premium auf Agenturniveau

Support nach dem Launch

Der Unterschied, der zählt

Schnelle Kommunikation

Modernstes Design

Performance Fokus

SEO Optimierung

Individuelle Entwicklung

Keine Templates

So arbeiten wir zusammen

Anfrage

Konzept

Entwicklung

Launch

Was Kunden sagen

Lass uns deine Website auf das nächste Level bringen.

Anfrage stellen

Wir entwickeln moderne Websites,
die Kunden gewinnen.