What we build
We take on four kinds of work. Each one ends with a system your business actually runs on, not a demo that stalls after launch.
Custom web applications
Most businesses eventually hit a point where spreadsheets, generic SaaS tools, or a patchwork of plugins stop being enough. That's usually when we get the call: an admin panel to manage a specific workflow, an internal tool that replaces three disconnected systems, or a customer-facing portal that needs to reflect exactly how your business operates, not how a template assumes it does.
We start by understanding the workflow itself — who uses the system, what they're trying to get done, and where the current process breaks down — before writing a line of code. The result is software shaped around your business, with room to grow as your process changes, rather than a rigid tool you have to work around.
These builds are usually smaller in scope than a public-facing product, but they carry more of your day-to-day operations than anything else we build. A workflow tool your team uses every morning has to be reliable in a way a marketing page doesn't, which is why we scope these projects around the two or three tasks that matter most rather than trying to replicate everything a legacy spreadsheet does on day one.
Built with: ASP.NET Core, Blazor Server, and Entity Framework Core.
E-commerce platforms
Off-the-shelf storefronts work well until your catalogue gets complicated — dozens of brands, model-specific variants, or a checkout flow that needs to do something the platform doesn't support. We build storefronts that handle that complexity directly: catalogue structures organised the way your customers actually search, admin panels your team can run without a developer on call, and checkout and ordering flows — including WhatsApp-based ordering, where that's how your customers prefer to buy.
BatteryCompany, one of our storefronts, organises its catalogue across roughly 28 device brands with a separate admin application for day-to-day management. It's a working example of this approach in production, not a proof of concept.
We also plan for the parts of e-commerce that don't show up in a demo: what happens when stock runs out mid-checkout, how returns and cancellations get tracked, and how the admin team finds a specific order among thousands without a support ticket turning into an afternoon of searching.
Built with: Blazor Server, ASP.NET Core, and SQL Server.
SaaS product development
Building a product you'll sell to many customers is a different problem from building a tool for one client. It means multi-tenant data isolation from day one, a pricing and billing model that doesn't need to be rebuilt at 100 customers, and an architecture that can absorb new features without a rewrite every year.
We approach SaaS builds the same way we're building our own product, GreenFrog CRM: start from a real workflow rather than a feature list, ship a narrow version that actually works, and expand from there based on what customers do with it rather than what looks good on a roadmap slide.
We also think about the parts of a SaaS product that are hard to retrofit later — billing and subscription state, role-based permissions across a team account, and audit trails for actions your customers will eventually ask about. Getting these right early is cheaper than bolting them on after your first enterprise customer asks for them.
Built with: ASP.NET Core, Angular or SolidJS, and PostgreSQL or SQL Server.
Maintenance & modernisation of existing systems
Not every project starts from a blank slate. We also take on systems that already exist — an ASP.NET or Angular application that's outgrown its original design, a codebase nobody currently on your team wants to touch, or a platform that needs to move onto a supported framework version before it becomes a liability.
This work is less visible than a new build, but it's where a lot of real business risk sits: unpatched dependencies, brittle deployment processes, and features bolted on faster than the architecture could absorb them. We audit what's there first, agree on what's worth keeping, and modernise incrementally so the system keeps running for your business while we work on it.
Sometimes the right outcome is a full rewrite; more often it's a targeted upgrade — a framework version bump, a database migration, or replacing one brittle integration — that removes the immediate risk without the cost and disruption of starting over. We'll tell you which one your system actually needs, even when that answer is smaller than a full rebuild.
Built with: whatever the existing system runs on — most often ASP.NET Core, Angular, or Blazor.
Not sure which of these fits?
Tell us what you're trying to solve and we'll tell you plainly what it would take.
Start a Project