Core platform
.NET 10 (C#) for business systems on the server and the desktop. Web services run on ASP.NET Core Minimal APIs, typically as Windows Services, with IIS where a client's environment calls for it. Hangfire handles background work.
A proven stack, chosen for the job and the handover
We choose technology around the work to be done, the client's environment, the support model, and who will own the system afterward. The default is straightforward: reuse tools we trust, keep the architecture understandable, and avoid building more system than the problem needs. Reusing a proven foundation is also part of how we move quickly.
The building blocks we standardize on
The exact stack depends on the system. These are our common building blocks, but we pick the right technology for each project and adopt newer ones when they are a better fit for the project.
Web front ends
Blazor Server for server-rendered internal systems that need tight, real-time control. React with TypeScript for customer-facing and multi-tenant apps, with Vite, React Hook Form, Zod, and TanStack Query. We also build, maintain, and modernize large, complex Angular applications across multiple versions, including data-heavy dashboards and interactive graph and network visualizations with ngx-graph.
Desktop apps
.NET 10 WPF with a Fluent interface and the CommunityToolkit MVVM pattern, shipped with signed installers and Velopack auto-update.
Mobile apps
React Native with Expo, so one codebase runs on both Android and iOS. We add offline support, GPS and mapping, camera capture, and turn-by-turn navigation where the work needs it.
Data and storage
PostgreSQL in production, with PostGIS for maps and routing, and SQLite for local and embedded storage. On existing systems we work across SQL Server, MySQL, Informix, Firebird, MongoDB, and Redis, so we can integrate with or migrate off whatever a business already runs.
Documents and data processing
Python pipelines for OCR and computer vision that read engineering drawings, scanned documents, and spreadsheets into structured data, and on the output side generate finished PDFs and spreadsheets such as reports and quoting workbooks.
Integration and EDI
We connect systems to ERPs, databases, and external services, and work across EDI standards by region and industry: X12 in North America, UN/EDIFACT internationally, automotive profiles such as ODETTE and VDA, and AS2 for secure transport. HL7 where healthcare calls for it.
Cloud and hosting
AWS for hosted systems, with EC2, Fargate, and RDS. Cloudflare for DNS, edge routing, a web application firewall, and managed HTTPS. We also use Hostinger and can extend to other platforms when they fit the client's support model.
Auth and access control
Application sign-in with JSON Web Tokens (JWT) and role-based access, so each user sees only what their role allows, alongside the network protections at the hosting layer.
Quality, testing, delivery
Automated tests with xUnit and pytest, structured logging with Serilog, and code coverage. Installers and deployment scripts are code-signed under one publisher identity, and releases ship through CI/CD so a build reaches production in a controlled, repeatable way.
AI, under engineering control
The Anthropic Claude API on commercial terms, and MCP servers that give an assistant a defined set of tools rather than open access. Where a problem needs it, we fine-tune and self-host our own models. Architecture, security, and release decisions stay with our engineers.
Reliability and ownership
Versioned releases, code signing, documentation that matches the code, and full source handover, so the system can be supported by us or taken in-house, with no lock-in.
Architecture judgment - there is no one architecture that fits every problem
Some projects need a simple service, a static site, or a small internal tool. Others need background processing, mobile apps, integrations, audit trails, or distributed cloud infrastructure. The value of experience is choosing the right level of complexity at the start: enough to do the job, not so much that the system becomes expensive to run and hard to hand over.
What we settle early
- Who will own and maintain the system after launch.
- Which integrations are critical and which can wait.
- Whether data needs audit history, isolation, or review controls.
- How the first release stays small without becoming disposable.
- What deployment, monitoring, and support model makes sense.
Not sure which technical path fits your environment?
A short prototype or proof of concept can validate the architecture, and show how it sits next to what you already run, before you commit to a larger build.