What you can hire us to do
Seven practices that combine into one delivery team based in Vancouver, British Columbia, Canada. Engagements usually start in one and pull in the others as the work demands - a kiosk project needs a cloud platform behind it, and a web app often grows a mobile client.
Websites & web applications
From a marketing site that loads fast to an application your business runs on.
Both ends of the spectrum, built the same way. A brochure site gets the same care about performance, accessibility and SEO that an internal platform gets about data modelling and access control. We work in your repo, in your process, against a plan you agreed to before anyone opened an editor.
What you get
- Product and technical discovery
- Design system and component library
- Server-rendered site or full application
- Typed API and relational data model
- CMS or admin so you can edit without a deploy
- Automated tests, CI, and documented handover
Mobile apps
iOS and Android - native where the hardware matters, cross-platform where it does not.
We pick the approach from the requirements, not from habit. Bluetooth, camera, background location and offline sync usually argue for native; a straightforward CRUD product usually does not. Either way you get store submission handled, crash reporting wired up, and a release process your team can run.
What you get
- Native (Swift, Kotlin) or cross-platform (React Native, Flutter)
- Offline-first sync and conflict handling
- Device integration: BLE, camera, NFC, location
- Push notifications and deep linking
- App Store and Play Store submission
- Crash reporting and release pipeline
IoT & embedded systems
Raspberry Pi, BeagleBone, Arduino, ESP32 - and the platform behind the fleet.
Connected hardware is two problems: the thing on the bench and the thousand of them in the field. We do both - firmware and device software, plus the ingest pipeline, provisioning, and over-the-air update path that keeps a deployed fleet maintainable.
What you get
- Firmware and device software (C/C++, Rust, MicroPython, Linux)
- Board bring-up on Raspberry Pi, BeagleBone, Arduino, ESP32
- Sensor integration and protocol work (MQTT, BLE, Modbus, LoRa)
- Telemetry ingest, time-series storage, dashboards
- Fleet provisioning and over-the-air updates
- Custom images with Yocto or Buildroot
Kiosks & interactive installations
Unattended screens that stay up, recover on their own, and resist curious hands.
A kiosk is embedded work wearing a touchscreen. The interface is the easy part - the hard part is a device that survives a power cut, a dead network, and someone trying to escape to the desktop. We build the lockdown, the watchdog, and the remote management that makes a estate of them supportable.
What you get
- Touch-first interface designed for gloves and glare
- Kiosk-mode lockdown and tamper resistance
- Offline operation with deferred sync
- Watchdog, auto-recovery, and remote reboot
- Peripheral integration: payment, scanner, printer, RFID
- Remote monitoring and content updates across the estate
Platform, cloud & observability
Infrastructure that is boring on purpose - and instrumented so you can see it.
Infrastructure as code, sensible environments, and deploys that are a non-event. We size for what you actually serve rather than what a reference architecture assumes. Then we instrument it, because a system you cannot see is a system you can only guess about.
What you get
- Infrastructure as code (Terraform)
- Container and deployment pipeline
- Dynatrace rollout: OneAgent, service flow, SLOs
- OpenTelemetry tracing and structured logging
- Alerting that pages a human only when it should
- Backup, disaster-recovery drills, and cost right-sizing
Data & AI
Pipelines and models that earn their operating cost.
Getting data into one place, keeping it trustworthy, and putting it to work. We build warehouses and pipelines, and where a model genuinely helps we ship it with evaluation and guardrails - not a demo that degrades quietly in production.
What you get
- Warehouse and schema design
- Ingestion and transformation pipelines
- Data quality checks and alerting
- Retrieval and LLM integration
- Offline and online evaluation harness
- Reporting layer your team can query
Modernization
Getting off the system that is holding the business back.
Legacy replacement without a big-bang cutover. We map what the old system actually does, carve out the parts that hurt most, and migrate incrementally behind a seam so the business keeps running the entire time.
What you get
- System and dependency audit
- Incremental migration plan
- Strangler-pattern implementation
- Data migration and reconciliation
- Parallel-run and cutover support
- Decommissioning checklist
We do not sell you the stack we happen to like
The right choice depends on what you are building, what your team can maintain, and what you already run. We are fluent across these and will tell you plainly when your existing stack is fine and the rewrite is not the answer.
Web front end
Chosen for the rendering model the product actually needs.
- React
- Next.js
- Vue
- Nuxt
- Svelte
- Astro
- TypeScript
- Tailwind CSS
Back end
Whatever your team can maintain after we leave.
- Node.js
- Fastify
- NestJS
- .NET
- Go
- Python
- FastAPI
- Django
- Laravel
- Rails
Mobile
Native when the hardware matters, cross-platform when it does not.
- Swift
- SwiftUI
- Kotlin
- Jetpack Compose
- React Native
- Flutter
Embedded & IoT
From a single sensor to a fleet in the field.
- Raspberry Pi
- BeagleBone
- Arduino
- ESP32
- C / C++
- Rust
- MicroPython
- Yocto
- Buildroot
- MQTT
- BLE
- Modbus
Data
Relational by default. Something else only when the shape demands it.
- PostgreSQL
- MySQL
- SQL Server
- SQLite
- MongoDB
- Redis
- ClickHouse
- dbt
- Airflow
Cloud & infrastructure
Your accounts, your bill, your keys.
- AWS
- Azure
- Google Cloud
- DigitalOcean
- Docker
- Kubernetes
- Terraform
- nginx
Observability
Instrumented before it is optimized.
- Dynatrace
- OpenTelemetry
- Prometheus
- Grafana
- Sentry
- Loki
Not listed is not a problem. We have picked up unfamiliar stacks on client systems plenty of times - that is a normal part of taking on existing code.
We use AI tooling throughout our builds
Not as a novelty and not as a substitute for engineers. It is part of the toolchain, the same way a compiler and a test runner are - and we are direct about where it helps and where it does not.
More of the budget goes to judgement
Scaffolding, migrations, test fixtures and boilerplate are the cheapest things to generate and the least valuable to bill you for. Squeezing that work leaves more of the engagement for architecture and the decisions that actually cost money to get wrong.
Test coverage that would not otherwise get written
The edge cases everyone agrees should be covered, and nobody has time for, get covered. That shows up later as fewer regressions rather than as a line item.
Faster reading of code we did not write
On a modernization job the first weeks go into understanding a system nobody documented. Working through it with AI assistance shortens that considerably, which is usually the longest pole in the tent.
A second reviewer on every change
Automated review runs over every diff before a human sees it. It catches the dull mistakes - an unhandled branch, a missing index, a leaked secret - so review time is spent on design.
What does not change: an engineer owns every line that ships. Generated code gets read, tested and reviewed exactly like handwritten code, and nothing reaches your repository that we could not explain in a code review. Where a client needs their source kept out of third-party tools, we work that way instead - just tell us up front.
Not sure which of these you need?
Most people are not. Describe the problem and we will tell you what the work actually is - even if it turns out to be smaller than you thought.