04 / DEVELOPMENT

Custom web & app development

Tailor-made websites, webshops, and apps — built on a modern stack and owned by you, not an agency.

The classic agency model is broken: someone builds your app, keeps the code, picks the hosting, and bills you every time you want to move a button. We work differently. We build on a modern stack — Next.js, React, Node, TypeScript, and Postgres — where the code is readable, documented, and portable. When we ship, the source lives in your Git repo, the deployment runs in your cloud, and runbooks describe every step from commit to production. You are not locked to us. The difference is that the same operator who runs your IT also builds your apps. The seam between "build" and "run" disappears: the developers writing the code sit next to the people watching it at two in the morning. We design for operations from day one — observability, error handling, security model, and update path are part of the delivery, not something you have to invent. For 17 years we have shipped over 1000 projects on this principle: you own the solution, we hand you the keys, and any competent developer can take over tomorrow.

1000+Projects shipped across 17 years

Is this a fit?

Founders who need an MVP web app or mobile app that can scale without a full rewrite in two years
Mid-size companies replacing an aging custom tool or an in-house-built ERP/CRM that no one dares touch
E-commerce teams looking to consolidate Shopify, a headless storefront, and payment flows on one modern platform
Operations teams who want to automate manual workflows through API integrations between existing systems

What we cover

Marketing sites and landing pages

Fast, SEO-strong sites built in Next.js and React with static rendering where it makes sense and dynamic routes where the content demands it. We design typography, motion, and responsive layouts from scratch, integrate with your CMS or deliver a headless setup on Sanity or Contentful, and ship a deployment on Vercel or your own cloud. Lighthouse scores in the green, WCAG 2.1 AA accessibility, and an editor flow your marketing team can actually use without calling a developer.

E-commerce — Shopify, headless, and custom

Shopify themes, headless storefronts on Next.js against the Shopify Storefront API, or fully custom checkout flows on Stripe and Node when your business logic does not fit a standard platform. We handle migrations from Magento, WooCommerce, and older PHP shops, integrate with Pensopay, MobilePay, ERP, and warehouse systems, and ship PCI DSS-compliant flows. Performance, conversion, and editor experience weigh equally — anything you sell should be buyable on 2G on a train.

SaaS web apps and customer portals

Multi-tenant SaaS, B2B portals, and internal dashboards built on Next.js, Node, and Postgres with authentication via NextAuth, Auth0, or Keycloak. We model the data layer with Prisma or Drizzle, expose GraphQL or tRPC to the frontend, and bake in audit logs, RBAC, and GDPR export from day one. The result is a web app that can run in your Kubernetes cluster or on Fly.io — and that ships with tests solid enough to deploy on a Friday afternoon.

iOS and Android mobile apps

Native apps in Swift (iOS) and Kotlin (Android) when performance, offline flows, or hardware integration demand it — and React Native or Expo when the codebase can be shared. We set up CI on Xcode Cloud or Bitrise, handle App Store and Play Store review, integrate push notifications via APNs and FCM, and build the backend as REST or GraphQL on top of Node and Postgres. The app binaries, signing keys, and developer accounts belong to you; we are only delegated admins.

API integrations and automation

When Microsoft 365, e-conomic, Dynamics, HubSpot, Pipedrive, or your warehouse system need to talk to each other, we write the integrations in Node and TypeScript with proper error handling, retries, and idempotency. REST, GraphQL, webhooks, and message queues on Redis or RabbitMQ — and scheduled jobs running in AWS Lambda, Cloud Run, or your own Kubernetes. We document every contract endpoint and ship monitoring so you do not discover a silent failure three weeks later.

How we work

Brief
We start with a two-to-four-hour workshop: your team, our tech lead, and a designer. We map business goals, users, existing systems, and success criteria. The output is a short brief — one or two pages — with scope, assumptions, risks, and three architecture sketches, each with its own price and timeline. No code yet; we would rather find disagreement here than in sprint three.
Spec
Based on the chosen track we build a technical spec: Figma wireframes, data model, API contracts, and ADRs (Architecture Decision Records) for the heavy choices. UX designer, backend lead, and a stakeholder from your side review it together. We split the project into milestones with concrete acceptance criteria — so billing and progress can be measured in delivered functionality, not hours.
Build
Two-week sprints with a demo at the end of each one. A small core team — typically a tech lead, one to three developers, and a designer — works toward the milestones from the spec. You get access to a private Git repo from day one, watch commits live, and share a dedicated Slack or Teams channel with the team. CI runs tests on every pull request; preview deploys let you click around before merge.
Hand-off
Once the functionality is in place, we shift into hand-off mode. We walk through the code live with your developers (or whoever you designate), update the README, runbooks, and deploy instructions, transfer admin rights to the cloud account, App Store, and signing keys, and run a two-to-four-hour training session. If you do not have an in-house dev, we still document as if you did — that is the only path to real ownership.
Run
After go-live there is a 30-to-90-day warranty period where we fix bugs without extra billing. After that, you choose: either you run the solution with your own team and use us as advisors, or you sign an operations agreement where we monitor, patch dependencies, and deliver feature work continuously. The switch can happen either way at any time — no lock-in, no exit fees.

What you walk away with

Source-code repository in your Git account (GitHub, GitLab, or Azure DevOps) — full history, no forks on our side
Architecture Decision Records (ADRs) documenting every heavy technical choice and the reasoning behind it
CI/CD pipeline and deployment runbook so any competent developer can ship from commit to production
Operations hand-off document with credentials inventory, monitoring setup, and incident playbook
Training session of 2-4 hours with your team, recorded and shared as video plus written notes
Warranty period of 30-90 days after go-live with bug fixes at no extra cost

Compliance & standards

GDPR
WCAG 2.1 AA
ISO/IEC 27001
PCI DSS (e-commerce)

Common questions

Do you pick the stack, or do we?

We recommend a stack based on your needs, existing systems, and the team that will run the solution afterwards. The default is Next.js, React, Node, TypeScript, and Postgres because it is widely supported and easy to hire into — but if you have a .NET background, a Python team, or specific requirements from a parent company, we adapt. The stack choice is documented as an ADR so you can always see why it was picked and when it should be revisited.

Who owns the source code?

You do. The source code lives from day one in a Git repository inside your organisation — typically GitHub, GitLab, or Azure DevOps — and we get access as collaborators. When the project ends, we remove our access and you keep full history, all branches, and all pull requests. There are no clauses in the contract that bind you to use us afterwards; ownership is real and transferred at the first commit, not when the invoice is paid.

Does the solution run in your cloud or ours?

By default yours. We provision — or use — an account at AWS, Azure, GCP, Vercel, or Hetzner in your name and deploy there. You pay hosting directly to the cloud provider with no markup from us. If you do not have a cloud account yet, we can temporarily run in our environment during build and migrate before go-live. We insist hosting sits in your name, because that is what makes it possible to change providers later without losing data.

Do you handle both design and development?

Yes. We have UX designers and developers on the same team, so design is not handed off as a static Figma file but evolves alongside the code. If you already have an external design agency or an in-house design team, we are happy to build on their mock-ups — we just need access to the Figma files and a short handover session. We do not build without a design track; unfiltered backend code in the frontend is a source of technical debt and gets expensive to clean up later.

How long does it realistically take?

It depends on the type. An MVP web app with authentication, a single domain module, and a simple backend usually takes 8-12 weeks from brief to go-live. An e-commerce migration — moving an existing catalogue to Shopify or a headless setup — runs 4-8 weeks depending on the number of integrations and PIM data. A mobile MVP for iOS and Android with shared backend runs 12-16 weeks including App Store review. We commit to a price and a timeline after the Brief phase — not before — because anything else is a guess.

How does maintenance work after go-live?

First comes a 30-to-90-day warranty period where we fix bugs at no extra cost. After that you have two tracks: either you run the solution with your own team and use us ad hoc as hourly advisors, or you sign an operations agreement where we monitor, patch dependencies, and deliver new features within a fixed budget. Both tracks are agreed up front, and you can switch between them without lock-in. We believe maintenance should be chosen, not imposed.

Ready to take the next step?

Send inquiry