Skip to content
//
Tour überspringen — zur FAQ

Four phases. No theatre.

How method64 builds. Discovery without an 80-page briefing PDF, architecture before the first line of code, the first increment live in week two, hypercare instead of "good luck!" at launch.

Large screen: a scroll-driven journey through four stations — Pinnwand, Blueprint, Inventory, Mission Control — then freely explorable.

STUDIO MAP — 4 STATIONEN, EINE TOUR
01Understand
Discovery —
without theatre.
DISCOVERY · TYPICALLY 3 DAYS – 2 WEEKS
1st CALL · THE QUESTIONS
Who actually decides?
What happens in 2 years?
Why now, and not later?
OBSERVED ≠ CLAIMED
"that's clearly defined"
→ 3 stakeholders, 3 versions
→ no shared definition
METHODS
· Stakeholder talks · 1:1 · 45 min
· Clarify constraints:
Budget · Time · Legal · Tech
· Quotes recorded verbatim
no workshop choreography, no 60-page PDFs
CONSTRAINTS · TYPICAL
Deadline: 12 weeks
Compliance: GDPR
Handover to team: yes
stakeholder map
Who
pays?
(budget)
Who
uses it?
(daily)
Who
decides?
(veto)
VOICE MEMO · 0:47
"we don't know who will use this later"
OPEN
What is
success in
6 months?
→ clarify in meeting 1
Climactra discovery
WON’T BE BUILT
IF EXCEL WILL DO
OUTPUT
Discovery doc
+ scope sketch
02Architecture
Three hours at the whiteboard beat six months at the refactor.
SYSTEM DESIGN · DRAFT
EDGE
FRONTEND
React · Vite
PROXY
nginx · TLS
SELF-HOST
APP
API
Fastify · Zod
AUTH
Auth.js v5
DATA
STORE
Postgres · Prisma
EU-DC
QUEUE
Redis
OBS
Sentry · Umami
COOKIELESS
EXAMPLEPOST/api/activityResponse<ActivityResult>
OpenAPI v3.1 · idempotent · auth required · Zod-validated
DECISION LOG
D-01
Hetzner instead of Vercel
Half the price, EU DC, own control
D-02
Auth.js instead of Clerk
No pricing cliff, self-hostable
D-03
Postgres + pgvector
One DB for everything, no second one for vectors
RISK REGISTER · TYPICAL PER PROJECT
Schema migration under load
Blue-green, expand/contract
Webhook retry · race
Idempotency keys + dedupe
Hetzner single-DC · no failover
Daily backup + monthly restore test
Container restart during deploy
brief downtime <10s · acceptable for static site
PERF TARGETS
LCP< 1.5s
INP< 200ms
CLS< 0.10
Bundle< 120kb (gzipped)
03Build
Atoms. Composition. Live.
A deployable slice every two weeks, no big-bang sprint after six months.
SLICE RHYTHM · 2 WEEKS · STAGING LINK · STATUS UPDATE
BUILD · PASSTAP · SHOWS USAGE ↓
INVENTORY · ATOMS
COMPOSITION · DASHBOARD
/dashboard
Overview · March
LIVE
VISITORS
∙∙∙
NO DATA
Email notification
search_|
Skip
Continue →
ITERATION · CTA BUTTON · v1 → v3
v1 · sunset
generic · "click" says nothing
learned
v3 · live
specific · clear verb
TESTS · CRITICAL PATHS
Tests where it hurts if they're missing.
Auth, billing, data migrations, edge cases, where things actually burn on client projects. The method64 site itself is static and needs no tests; the principle applies on software projects.
04Launch + Iterate
Go live, and then don't walk away.
Launch isn't the goal, the first day users actually work with it is.
Docker · nginx · rollback via git revert
DEPLOYMENT PIPELINE
git push
main branch · build triggered
tsc + asset-check
TypeScript strict · fail fast
vite build
dist/ + Docker image
Bundle gate
120 KB max · build fails on overshoot
docker compose up
Hetzner FSN1 · nginx serves dist/ statically
verify-production
60+ curl smoke tests · i18n, sitemap, assets
$ docker compose up -d --force-recreate
or: git revert HEAD && git push, container rebuilds from previous commit
HYPERCARE · 4 WEEKS AFTER LAUNCH
01
Same response time as before
usually same business day
02
Logs are read, not just stored
Sentry issues triaged, not just registered
03
What surfaces gets fixed
small issues without an hour ledger
04
Written status update
weekly or on demand
AFTER · Pay-per-use · no minimum retainer
+ lift-out doc
→ lift-out sessions on request
WHAT IS MONITORED · WITH WHAT
ERRORS
Sentry
stack trace · source maps
PAGEVIEWS
Umami
self-hosted · cookieless
PERFORMANCE
Lighthouse
DevTools / PSI · manual after deploy
UPTIME
UptimeRobot
multi-region · 1-5 min interval
Maintenance is transparent, or there is none.
YOU'VE SEEN
01Understand
02Architecture
03Build
04Launch + Iterate

Four phases.
Your project.

Initial call no commitment. Paid discovery follows, with an honest output, even if that output is "Excel will do".

Get in touch →

This site itself is built this way. Pipeline live, monitoring live, hypercare mindset too.

FAQ

Common questions about the process.

What clients ask before they say yes.

  • Between three days and two weeks, depending on complexity and how many stakeholders need to be involved. For a focused marketing site, two meetings often suffice. For a multi-tenant SaaS with three user groups + compliance requirements, 8–12 hours of interview time spread over two weeks is more realistic. Important: discovery isn't a "free pitch". It's billed as the first real block of work, if you don't want to continue building afterwards, you still have a cleanly documented discovery to take with you.

  • That's exactly what the phases are cut for. The architecture phase is the last realistic place where you can change scope without pain, after that there's code that needs to be adapted. But everything is deliberately built so pivots are also possible within the build phase: slice planning is reassessed every two weeks, feature flags allow rolling away without rollback stress, and the repo documents why each choice was made, so a later change doesn't mean: "why was it actually done this way?".

  • Every two weeks a slice ships with a short status update. If needed, a 30-minute meeting, otherwise coordination runs asynchronously. Retros after each slice in writing, not as a 90-min workshop. Half the Scrum rituals are bureaucracy that small teams don't need. The other half, slice demo, written update, clear next step, is useful. Those stay.

  • Yes, and it usually makes the result better, because you bring domain knowledge that could never be caught up from the outside. Three models are on the table, depending on team bandwidth: (1) method64 builds, your team reviews PRs and takes over after 4–8 weeks, lift-out scenario. (2) Mixed pair: method64 and your senior work on the same slice, you learn the stack while it's being built, competence transfer. (3) method64 builds frontend, you build backend (or vice versa), when you're strong in one and outsource the other. Which model fits gets clarified in discovery, usually it follows from your team's capacity.

  • Three options. (a) Pay-per-use: you reach out when something's up; billing is by the hour. No minimum retainer. (b) Fixed hour budget per month (typically 4–16 hrs), included maintenance + monitoring reviews + small adjustments. (c) Lift-out: handover sessions for your team, after that the product runs entirely with you. The usual recommendation is (a) first, when volume becomes noticeable, switch to (b).

Question not listed?

Ask directly →