Independent Engineering · Custom Software
Standard software solves standard problems. But when your business model isn't standard — a member platform for an association, an auction app, a digital product with its own pricing logic — it pays to invest in your own software instead of forcing a SaaS that will never quite fit.
Decision support
Custom software isn't always the right choice. Four scenarios where it is — and three where you're better off staying with standard.
You sell a digital product — a member platform, a marketplace app, a SaaS tool for an industry niche. Here, software is the asset itself. SaaS building blocks help, but the core experience must belong to you.
You tried standard software but hit platform limits on a significant share of requirements. Customization becomes more expensive than a build, or the platform starts breaking your use case in updates.
You have 50 users of a SaaS solution today; in 3 years it will be 5,000. With many SaaS models, 5,000 users become a cost block where a build would already amortize after 18 months.
Public sector, associations, healthcare, critical infrastructure. Or a deliberate decision to reduce US-cloud risks (Cloud Act, Schrems II constellations). Custom on Hetzner or STACKIT is often the clean answer here.
Internal tool mapping a business process, with 5–50 internal users, that you need in 8 weeks. Here Microsoft Power Platform is typically faster, cheaper, and more maintainable long-term.
HR system, accounting, classic CRM for a 30-person sales team. Mature SaaS providers exist there. Custom software in these areas is mostly symbolic politics — and an expensive reminder that the standard tool would have been faster.
Tech stack
We rely on a proven, end-to-end TypeScript-based stack. The argument is pragmatism: one stack, one language, shared knowledge across the team — from UI to database migration. No polyglot architecture in which every microservice is written in a different language.
Server rendering for good load times and SEO. App Router. React Server Components where it makes sense. Tailwind for stylistic consistency. Form validation with Zod. We build UIs that stay fast at scale — even with real data volumes.
NestJS brings a clean module structure, dependency injection, built-in test patterns. For API endpoints, REST or tRPC depending on the case. Job processing with BullMQ, authentication via OIDC or magic link.
PostgreSQL covers 95% of all relational use cases. With extensions like pgvector, also embeddings for AI applications. Migration management via Prisma. Backups hourly, one-click restore.
Hetzner Cloud from Falkenstein and Nuremberg for most projects. STACKIT (Schwarz Group, Heilbronn) for customers with higher sovereignty requirements. Both 100% EU-operated, significantly cheaper than AWS/Azure and without US Cloud Act exposure.
Three project shapes
Which form fits depends on where you are and what the end state should look like.
You have an idea but no clear solution path. In 2–4 weeks we validate the key technical assumptions, build a click-able prototype, and deliver an architecture sketch + roadmap.
From prototype to a working product with real users. In 2-week sprints, with weekly demos, clearly focused on the core workflow. Anything not essential for the first users moves into the roadmap behind it.
You have your own product team but need 1–3 experienced engineers for a specific phase or permanently. We work with you, in your repository, in your sprints, with your reviews.
Sovereignty anchor
EU hosting as standard. Hetzner (Falkenstein, Nuremberg) or STACKIT (Heilbronn). Both without a tie to the US Cloud Act. Backups stay in the EU, logs stay in the EU, identity provider stays in the EU.
Open source by default. Frameworks and libraries are open-source — Next.js, NestJS, PostgreSQL, Prisma. In an emergency, you can take over each building block yourself or have another provider continue development.
Code ownership with you. Repositories, CI configurations, infrastructure-as-code scripts — everything moves into your GitHub or GitLab organization. We work as guests in your house, not the other way around.
Vendor lock-in protection. We deliberately avoid proprietary dependencies that would make a switch expensive. PostgreSQL instead of a cloud-specific database. Container workloads that run on any cloud provider. Standardized API designs.
Audit-readiness. Structured logs, data model documentation, ADRs (Architectural Decision Records). So every later engineer — internal employee or other provider — understands why something was built that way.
Live reference
The License Cost Calculator at licenses.arades.de is an example of exactly the approach we sell. Next.js on Hetzner, PostgreSQL as database, Microsoft licensing model logic mapped in TypeScript. Result: a tool with which sales and IT leads get a valid license calculation for Microsoft Dynamics 365 in 5 minutes.
Eat your own dogfood. We sell custom software development and use it ourselves — as marketing vehicle, as sales tool, and as proof that the approach works.
Further
Custom software often only becomes truly useful through an AI integration. We combine with OpenAI, Claude, Mistral, or local LLMs.
Before building: clarify build vs. buy. Microsoft vs. open source. Assess EU sovereignty. 45-minute conversation or multi-day workshop.
The overview of our second pillar — everything that doesn't directly belong to the Microsoft world but is strategically and operationally important.
When the Microsoft path fits. Power Apps, Power Automate, Power BI, Power Pages — often the faster alternative to custom software.
FAQ
When standard software doesn't cover the business model, when you want to build a digital product for your customers, or when license costs at a certain scale no longer make sense. If Microsoft Power Platform, Dynamics 365, or a standard SaaS meets your requirements, we'll say so — and recommend the standard path.
By default TypeScript, Next.js (frontend), NestJS (backend), PostgreSQL as the database. Hosting at Hetzner or STACKIT in Germany. Optional: Prisma as ORM, tRPC for type-safe APIs, Redis for caching, S3-compatible storage. We use a proven stack — no framework roulette.
A discovery spike (2–4 weeks) we calculate together. An MVP (2–4 months) sits within a fixed-price range. An embedded team (1–3 developers, monthly) in embedded-team mode. We calculate transparently — no hidden "discussion hours."
You do. Source code, repositories, CI/CD pipelines, infrastructure — everything moves into your ownership. You can switch to another provider at any time or take maintenance in-house without vendor lock-in. That's part of our sovereignty approach.
By default Hetzner (Falkenstein, Nuremberg) or STACKIT (Heilbronn). Both 100% EU-operated, GDPR-compliant, without US Cloud Act exposure. For specific requirements (healthcare, public sector) also Open Telekom Cloud or IONOS. AWS or Azure only when the customer explicitly requests it.
Yes — as a standalone discipline. iOS and Android apps with .NET MAUI for Microsoft-adjacent stacks, React Native for broad cross-platform projects, or native Swift/Kotlin when the task demands it. If your use case is feasible with a progressive web app, we'll say so — otherwise we go the mobile route.
Both. We take over existing codebases (code audit first), modernize older stacks (e.g. PHP-Laravel or Ruby-on-Rails to Next.js/Nest), or build complementary modules. The prerequisite is a realistic view of technical debt — for very old codebases we often recommend a parallel rebuild alongside the legacy system.
45 min · free · no obligation
45 minutes in which we walk through your specific idea technically. Make-or-buy, stack choice, hosting location, budget realism. With the person who will later build it. No prep pressure — bring what you have.
Accompanying services
Engineering projects rarely stand alone — license logic, architecture clarification, quality gates, knowledge transfer, and follow-on operations usually run in parallel. Below are the most common accompanying services we add via discovery spikes, fixed-price sprints, or application-care contracts.
Before · Architecture
Before implementation: tenant structure, data model, security concept, integration mapping. The result is an architecture document any engineering team can continue working with — even one other than us.
Read more →
Before · CSP
Which license bundles for which users, which add-on SKUs are necessary, where you're over- or under-licensed. Sourced as a Microsoft Licensing Partner — with the option to use CSP purely for control without margin maximization.
Read more →
During · Quality gate
Independent second opinion during an active implementation project — whether we run it or another partner does. CMMI-based quality gates, risk reviews, fixed price per gate.
During · Adoption
Not the classic 2-day workshop forgotten after a week — but a dynamic learning program over 4–6 weeks with initial training, application phases, and follow-up sessions. Training matrix for roles and topics.
Read more →
After · Operations
After go-live: a plannable application-care contract with a monthly flat rate, SLA-based. Includes releases, hotfixes, extensions, tenant hardening — and continuous accompaniment instead of mere ticket response.
Read more →
After · Knowledge
When the original developers are gone, the previous partner is no longer reachable, or the documentation is stale — reverse engineering of the existing solution with a documented result: code map, data model, customization inventory.
Read more →
