What we do

Modernization that actually ships

Every engagement here starts from the same question: what are you trying to get to, and what is standing in the way? Most of our clients have real deadlines, real constraints and operations that cannot stop while the software is replaced. So the work is shaped around the outcome you are after — not around billable hours.

How we engage

Three ways to bring us in. Most clients start with one and grow into another.

Fractional CTO

Senior technical leadership without a full-time hire — for teams that need direction, not just delivery.

  • Architecture and technology strategy
  • Roadmap, build-vs-buy and cost control
  • Hiring, code review and team mentoring

Team Augmentation

Drop-in senior engineering that ships from day one and leaves your team stronger than it found them.

  • Embedded delivery alongside your developers
  • Unblocking stalled or inherited codebases
  • Standards, CI/CD and review practices that stick

Idea to Product

Business analysis and discovery that turns a rough concept into a scoped, costed, buildable plan.

  • Requirements and technical feasibility
  • Prototypes and architecture proposals
  • Phased delivery plan with real estimates
AI

Bringing your data the right way

Most AI projects stall long before the model is the problem. The data it needs is sitting on a device, inside a legacy system, or in a format nothing can query. We work the whole path — from where the data is created to the point an assistant can use it safely.

Data Foundations

The unglamorous half: getting your data from where it is created to somewhere a model can reach it, without losing any along the way.

  • Edge and device capture, offline first
  • Background sync and reliable transfer
  • Storage, cleanup and a schema that holds up

Model Access & Tooling

Exposing your systems to an assistant on purpose rather than by copy-paste — with clear boundaries around what it can see and do.

  • MCP servers over your existing APIs and data
  • Retrieval and grounding on your own content
  • Permissions, tenancy and audit trails

AI in the Product

Assistants, speech and automation built into the app your users already have open, instead of another tab they have to remember.

  • In-app assistants that know your data
  • Speech, wake word and hands-free workflows
  • Automating the steps people repeat daily
Responsible adoption

Getting there without betting the business

The failure mode is rarely the technology. It is a rollout nobody measured, data that went somewhere it should not have, or a process quietly handed to a model that nobody is accountable for. These are the rules we hold to on every AI engagement.

Start where it pays

One workflow with a cost you can actually measure, proven before anything expands. Company-wide rollouts on a hunch are how AI budgets get cancelled.

Your data stays yours

What leaves your network, what a vendor may train on, and where regulated data is allowed to live — decided deliberately and written down before the first prompt.

People stay accountable

Anything touching money, safety or a customer keeps a person approving it, and the system records who decided what. The AI drafts; your team signs.

Measured, not assumed

Evaluated against real cases from your business, so you know the accuracy before your customers find it — and so you can tell when the model starts to drift.

No lock-in by default

The model is a replaceable part. Your data, your tools and your evaluations are the asset, and they stay portable the next time this market moves.

An honest no

Some processes should not be automated, and some problems are cheaper to fix with a better screen. We will say so before you have paid for the alternative.

Where we usually start

A short review of what data you already hold, what you are throwing away, and what a model would actually need to answer the questions your business cares about. It normally takes a couple of weeks and produces a plan you can cost — often with the useful finding that the first phase is plumbing, not AI.

Capabilities

The technology underneath

A short list on purpose. These are the areas where we are genuinely among the people you would want on the problem — mobile, connected devices, and the cloud services that tie them together.

Mobile & Cross-Platform

Production .NET MAUI, iOS and Android apps — including the background, offline and lifecycle work most teams get wrong.

IoT & Bluetooth

BLE central and peripheral, device fleets and hardware integration. We wrote the libraries the industry uses for this.

Fleet & Field Operations

Location tracking, geofencing and telematics for vehicles and crews working where connectivity is not guaranteed.

Cloud & Web Applications

The ASP.NET Core services and APIs behind the device — built to deploy cleanly, stay cheap to operate, and hold their shape when the fleet all reports in at once.

Application Modernization

Moving legacy .NET Framework and aging mobile codebases onto current platforms without stopping delivery.

Who we build it for

The businesses we have shipped into

Twenty-five years in operations where the software has to survive contact with the real world — trucks, warehouses, job sites, hospital floors and call queues.

  • Fleet ManagementVehicle tracking, telematics and dispatch for crews working well outside coverage.
  • WarehousingScanning, inventory and floor operations that keep working when the Wi-Fi does not.
  • Commercial Real EstateBuilding systems, access control and tenant-facing apps tied to real hardware.
  • Construction ManagementSite capture, progress reporting and workflows for people who are never near a desk.
  • Medical DevicesConnected devices and companion apps where reliability is not a nice-to-have.
  • Contact CentresAgent desktops, telephony and CRM integration, and the automation that keeps routine calls off the queue.
  • & moreIf your business runs on people, vehicles or hardware away from an office, we have shipped something like it.
Xamarin → .NET MAUI

Everything your Xamarin app depended on, we already own

Xamarin went out of support in May 2024. The part that stalls these ports is almost never the UI conversion — it is the dependency list. Every abandoned plugin behind Bluetooth, background jobs, location, push, storage and sync has to be replaced by something nobody on the team has run in production yet. That evaluation is where the months go, and where the risk sits.

How the port usually goes

  • Weeks auditing dead plugins and choosing replacements sight unseen.
  • It compiles, it demos, and then background, offline and Bluetooth behaviour quietly regresses on real devices in the field.
  • Whatever no replacement covers becomes bespoke platform code your team now owns forever.
  • Feature delivery stops for the duration, because everyone is on the migration.

How it goes with us

  • The dependency audit is mostly a lookup. We know what replaces what because we publish and maintain the replacement.
  • The dangerous subsystems arrive already solved — shipping on iOS and Android, in other people's production apps, today.
  • We have run this port enough times to know where it actually bites, so the estimate is based on the work, not on optimism.
  • You land on open source libraries with 50M+ downloads, not on a private shim only the contractor understands.

Covered in house, already in production

There is no section of a mobile app where we hand you back a list of options to go research. Pick any part of the old app — the answer already exists.

  • Bluetooth & hardwareBLE central and peripheral, GATT, L2CAP, and the pairing and reconnect behaviour that only shows up on real devices.
  • Background jobsWork that keeps running against the OS schedulers on iOS and Android instead of dying with the app.
  • Location & geofencingGPS tracking, geofences and motion activity, including the background permission dance both stores enforce.
  • Push notificationsNative APNs and FCM on the device, Azure Notification Hubs if you use it, and the server side that dispatches them.
  • Local notificationsScheduling, repeats, channels, badges and interactive actions across both platforms.
  • Offline storageSettings and key/value stores, plus a document database over SQLite and the server engines behind it.
  • Sync & transfersBidirectional sync and background upload/download that survive dead zones, suspension and battery savers.
  • Speech & audioSpeech to text, text to speech, wake word and hands-free flows for people who cannot hold a phone.
  • Device dataContacts, health data, the music library and permissions handled the way each platform expects.
  • Barcodes & scanningCamera scanning and rendering across the symbologies warehouse and field apps rely on.
  • UI controlsTable views, tree views, overlays, chat, image editing, pickers and badges — the control suite the old apps leaned on.
  • App architectureDependency injection, hosting, navigation, localization and mediator patterns, so the shape of the app survives the move.
  • AI in the appAssistants, chat and voice built in while you are already in the code, if the rebuild is the right time for it.

How we start a migration

A dependency and risk pass over the existing solution — what maps straight across, what has no equivalent, and what should not survive the move at all. It comes back as a phased plan you can cost, and the port runs platform by platform alongside your roadmap rather than freezing it.

.NET Modernization

Every stack on this list, shipped in production

Legacy .NET is not one problem. A WebForms app, a WCF service layer and a WinForms client each stall for entirely different reasons, and an estimate is only as good as whoever has actually lived in that stack. We have written production code in all of them — including the VB.NET ones nobody wants to open — so the assessment is recall rather than a research phase you pay for.

  • 2002 – 2012ASP.NET WebFormsASP.NET Core with Razor Pages or Blazor

    The page lifecycle, ViewState and server controls have no equivalent, so the markup genuinely is rewritten. The business logic underneath it usually is not — and pulling the two apart is most of the job.

  • 2003 – 2010ASMX and WCF servicesASP.NET Core APIs, gRPC, or CoreWCF

    Bindings, behaviours and SOAP contracts do not port. Where the callers are third parties you cannot change, CoreWCF keeps the contract alive while everything behind it moves.

  • 2007 – 2015Silverlight and browser-plugin clientsA web front end, or a mobile app

    There is nothing to migrate to — the runtime is gone from every browser. These start as a scoping conversation about what the application actually needed to do.

  • 2008 – 2019DataSets, EF6 and hand-rolled ADO.NETEF Core, or Dapper where it earns it

    The data layer is where a straightforward port turns expensive. Query translation, transactions and lazy loading all behave differently, and it shows up in production rather than at compile time.

  • 2009 – 2016ASP.NET MVC 5 and Web API 2ASP.NET Core MVC

    The closest thing to a mechanical port on this list. The real work is hosting, configuration, dependency injection and the middleware pipeline — not your controllers.

  • 2002 – todayWinForms and WPFCurrent .NET desktop, or MAUI if it belongs on a phone

    Both still run on modern .NET, so this is rarely a rewrite. What blocks it is abandoned third-party control suites and COM interop, which is the first thing we go looking for.

  • Any version.NET Framework class librariesCurrent .NET, multi-targeted during the move

    Shared libraries are what let the old and new systems run side by side. Getting them multi-targeting first is usually the unlock for everything else on this list.

  • Ongoingpackages.config, legacy csproj, IIS on Windows ServerSDK-style projects, containers, CI that runs itself

    Unglamorous, and it is what makes the rest repeatable. It also pays off long before the migration finishes, which is why it is often the right thing to do first.

No big-bang rewrites

Nothing on this list gets replaced in a single drop. The shape that works is a strangler: stand the new stack up beside the old one, move a slice at a time behind the same URLs, and keep both running until there is nothing left on the old side. It looks slower on paper, and it is the only version of this we have seen finish.

Not sure which one you need?

Tell us what you are trying to build. We will tell you honestly whether we are the right fit — and what we would do first.