Custom software
Custom software for the web, engineered to be handed over
Custom web applications, SaaS platforms and APIs, designed, built or modernized in TypeScript, .NET or PHP and run on AWS, Azure or Google Cloud. A senior engineer leads each build from the first call, significant decisions are written down before code, and every change passes automated quality gates before it merges.
- Typical timeline
- 3–6 months for most buildsAfter a short discovery sprint
- How it’s quoted
- IndividuallyAfter a 30-minute call
- Who edits it
- Your teamThrough an admin we build or a CMS we integrate
- Stack
- TypeScript, .NET or PHPReact, Vue or Angular; AWS, Azure or Google Cloud, including serverless
In your name Accounts and repositories, from day one Yours The code and documentation, under the signed agreement
On this page
Is it the right call?
When it’s the right call
- Off-the-shelf software forces your process to bend around it
- You are building a product that customers log in to and pay for
- Several systems need to share data through reliable APIs, not spreadsheets
- An existing .NET or PHP system needs modernizing without a risky rewrite
When it isn’t
- A marketing site with a blog and a contact form We’d suggest: A website on WordPress, Squarespace or Wix
- A proven SaaS product already does 90% of what you need We’d suggest: Configure that product, and we build the integrations around it
- An existing system works, rarely needs to change and is still supported We’d suggest: Keep it, and revisit modernization when it has to change
Sound like you? The first step is a 30-minute scoping call with the engineer who would lead the work.Request a scoping call
Two ways to start small
- Fixed scope, usually 2–3 weeks
Discovery sprint
Research into your users, systems and constraints, the architecture decisions written down, and a written plan and quote, yours to take to any team.
Start with a discovery sprint What the written plan covers - Scoped and quoted on its own
Already running a system that’s hard to change?
Modernization audit
The code, dependencies, data, hosting and releases reviewed, the risks ranked in a written report, and a step-by-step plan. Nothing beyond the audit is committed until you decide to go further.
Start with an audit What the audit report contains See a sample report
Standard equipment
What we usually hand over on a project like this. Your proposal lists exactly what’s included.
- TypeScript
- React
- .NET
- PHP
- AWS
- Vue
- Angular
- Laravel
- Blazor
- Azure
- Google Cloud
- PostgreSQL
- Next.js
Architecture decision records
Every significant technical choice written down, with the options considered and the reason one won.
Application and cloud infrastructure
The environment your software runs on, set up in your AWS, Azure or Google Cloud account and documented for your team.
Modernization roadmap
For existing systems, an audit and a step-by-step plan to upgrade or replace parts while the system stays in use.
APIs and integrations
APIs designed, built and documented for your apps and partners, and integrations with alerts when a sync fails.
Automated quality gates
Tests, accessibility checks and performance budgets that run on every change before it merges.
Handover documentation
Runbooks, setup guides and a codebase tour your next engineer can follow on day one.
Specialties
SaaS platforms
Multi-tenant products with billing, roles and onboarding, designed so the second hundred customers cost less than the first.
Cloud & APIs
Infrastructure and APIs your software can rely on, in your own AWS, Azure or Google Cloud account, documented so anyone can run them.
Modernization
Existing .NET, PHP and JavaScript systems made safe to change again, one release at a time, planned to keep the system in use.
What we build
Customer portals and self-service tools. Internal applications that replace spreadsheets and manual handoffs. Multi-tenant SaaS platforms with billing, roles and audit trails. APIs that let your systems share data reliably, and fast, accessible front ends over systems you already run. AI features, such as search that understands plain language or an assistant that can see a customer’s account, go in where they earn their place, with guardrails you can audit (AI consulting).
Modernizing what you already run
Not every project starts from scratch. Often the system already works but has become hard to change: an aging .NET application, a PHP codebase that has grown for a decade, a front end nobody wants to touch. We modernize in steps rather than betting the business on a rewrite. First an audit and a written plan of what to keep, upgrade or replace. Then tests around the behavior that matters, and the riskiest parts moved forward one release at a time. Not sure where yours stands? Take the readiness check. Running .NET 8 or .NET 9? Support for both ends on 10 November 2026: moving to .NET 10. How we modernize .NET and PHP systems →
APIs and cloud infrastructure
Sometimes the API is the product. We design, build and document APIs your own apps and partners can rely on, versioned so they can change without breaking anyone, and integrate with the ones you already depend on. Underneath, the infrastructure is set up in your own AWS, Azure or Google Cloud account, and it can stand on its own as well as sit under a build. Cloud infrastructure and APIs →
Working in your stack
We work in the stack you already run, or the one the problem needs, and recommend it in writing. Back ends are typically TypeScript or C# and .NET, and PHP applications often run on Laravel. Front ends are built in React, Vue or Angular. For teams already invested in .NET, Blazor keeps the front end in C#. Where a workload is event-driven or uneven, serverless functions such as AWS Lambda or Google Cloud Functions keep it simple to run.
How a build runs
A short discovery sprint turns the idea into decision records, plus a written plan and quote. The build then runs in weekly increments you can click through.
Questions about custom software
How much does a custom web app cost?
Every custom web app is quoted individually, and we don’t publish rates. The price follows scope: how many systems the app connects to, how many user roles and workflows are new, how much data has to move across, and the level of security review required. For larger builds, a 2–3 week discovery sprint produces decision records, plus a written plan and quote, before you commit to the build.
How long does a custom web app take to build?
Most builds take 3–6 months after discovery, depending on scope. The same things that shape the quote shape the schedule, and the discovery sprint turns them into a dated plan, so you know what ships when before the build begins. You see working software long before launch.
Should we build custom software or buy an off-the-shelf product?
Buy when a proven product already covers most of what you need; build when the work that sets you apart is exactly what off-the-shelf software can’t do. Before recommending a custom build, we compare the options in writing, including what each will cost to run and change over several years.
Who owns the code when the project ends?
The repositories and cloud resources sit in your organization’s accounts from the start, and the code we write for you is yours under the signed agreement. We work through access you grant and can remove, so ending an engagement means revoking access, not transferring anything.
Every build, any stack
One standard.
Performance
A performance budget is set before launch and enforced on every change.
Accessibility
Built to WCAG 2.2 AA and tested against it, with automated checks and manual keyboard and screen-reader passes on client builds.
Security
Least-privilege access, secrets kept out of code, dependencies monitored and security headers configured.
Handover
Accounts and repositories in your name from day one. The code and documentation are yours under the signed agreement, written so another team could take over.
Start a project
Tell us what you’re building.
We reply within one business day, with questions or a time to talk.
Pittsburgh, PA · Since 2015 · First step: a 30-minute call