What we build.
Custom web applications.
4–12 weeksFull-stack web applications built from scratch to fit your business — not the other way around. We pick boring, well-supported tools and write code your future self (or any senior engineer) can read. The whole codebase is yours on day one: source, infrastructure, accounts, data. No SaaS rent. No per-seat fees. No vendor standing between you and your own software.
What you get
- A real codebase any senior engineer can pick up and ship from on day one
- A deploy pipeline (GitHub Actions → AWS or your cloud) that ships in under five minutes
- Documentation for the systems your team will need to operate
- Weekly demos until you sign off — adjust as we go
- On ship day, the keys: code, server, accounts, data, IP
Stack we like
- Laravel
- Astro
- React
- Node
- PostgreSQL
- SQLite
- AWS
- Cloudflare
Past work
AI features that ship.
2–8 weeksPractical AI inside real product flows. We wire OpenAI, Anthropic, and local models into the tools you already run — chat, summarization, retrieval, agents that do actual work. Every feature is scoped against a real user task, with token budgets, evals, and a fallback plan when the model is wrong. We ship things you can stand behind, not demos.
What you get
- A short scope: which user task, which model, what good looks like
- A working feature behind a feature flag, with usage and cost telemetry
- Prompt and retrieval pipelines you can edit yourself
- A small eval set so regressions get caught before users do
Stack we like
- OpenAI
- Anthropic
- pgvector
- Whisper
- Python
- Node
Past work
Rescue inherited code.
2–6 weeksInherited code is a different kind of work. The first week is reading: what's there, what's load-bearing, what's a trap. Then a written report — what we'd keep, what we'd cut, what it costs to ship. We've taken over projects that three teams already gave up on and pushed them into production. No blame. We just keep going until the thing works.
What you get
- A written audit: what we found, what to keep, what to cut, what it costs
- A short list of bugs fixed in the first two weeks so you can feel progress
- A path to ship — concrete, dated, scoped to what's actually needed
- Documentation as we go, so the next person inherits something readable
Stack we like
- Whatever the project uses
Past work
Infrastructure & DevOps.
1–3 weeksMost teams pay too much for infrastructure they don't need. We set up servers you understand: a single AWS box running Postgres, Redis, and your app behind Nginx, with GitHub Actions deploying on every push. Self-hosted where it makes sense, managed where it earns its keep. Predictable bills, owner-readable configs, no surprises at scale.
What you get
- A provisioned production environment (AWS or your cloud) with backups and monitoring
- GitHub Actions CI/CD that runs tests, builds, and deploys on every push to main
- SSL via Let's Encrypt, Nginx config in version control, zero-downtime reloads
- A README your on-call engineer can actually follow at 3 a.m.
Stack we like
- AWS
- Docker
- Nginx
- PM2
- GitHub Actions
- Let's Encrypt
Past work
Process automation.
1–4 weeksThe unglamorous software that quietly saves your team a day a week. Internal tools, scrapers, schedulers, integrations between the systems you already use. We start by sitting with the person doing the work, watch where the time goes, and build the thing that takes that time back. Boring, durable, owned outright.
What you get
- A workflow audit: where the hours go, what is worth automating first
- A working tool or job — Python, Node, or a small admin UI — running on a schedule
- Logs, alerts, and a rollback plan, so a quiet failure does not become a loud one
- Hand-off documentation written for the person who will run it after we leave
Stack we like
- Python
- Node
- PostgreSQL
- Cron
- Playwright
Past work
Pair-program with your team.
Hourly or weeklySometimes you don't need us to write the code — you need a senior engineer in the room while your team writes theirs. We pair on real features, run architecture reviews, debug the gnarly thing that has been blocked for a week. Your team keeps the work. We just leave them sharper than we found them.
What you get
- Scheduled pairing sessions on real tickets — not contrived exercises
- Written notes after each session: decisions made, follow-ups, things to read
- Architecture and code reviews on PRs your team is shipping
- A standing weekly office hour for the questions that pile up between sessions
Stack we like
- Whatever you use
A note on pricing.
We don't publish rates because every project is scoped on its own terms. Most projects start in the low five figures and scale from there, depending on what you actually need.
We send a written, fixed-price proposal once we understand the work — what we'll build, what we won't, how long, and what it costs. We never bill hourly without asking first.