Web applications
Custom software in the browser: a portal your client’s customers log into, a dashboard their team runs the day from, an internal tool that replaces the spreadsheet that replaced a process.
For agencies that sell strategy, design, or marketing — and keep meeting clients whose real request is a piece of software.
- Fixed-price / build
- $8,000–$25,000
- Pilot to proof
- 2 weeks
- Defect warranty
- 90 days
Custom, and deliberately boring.
This is the classic build: auth, roles, data, and screens, shaped to one business. It starts where off-the-shelf ends — when the client has outgrown the spreadsheet, the no-code tool, or the plugin, and the workarounds cost more than the software would.
Custom doesn’t mean exotic. The stack is deliberately boring — Next.js and TypeScript, a managed Postgres, hosting the client can hold the keys to — because your client will own this system for years, and boring is what still has documentation, updates, and available engineers in year five.
AI features slot in where they earn their place — document upload that files itself, search that answers questions — as scoped features with the same engineering discipline, never as a headline.
Most applications live or die on the systems around them — billing, CRM, email — which is integration work under the same roof. Read about API integrations.
When custom is the right recommendation.
The spreadsheet broke
The operation runs on a workbook only one person understands, with real money moving through it. A small internal tool with roles, validation, and history is usually the request behind the request.
Customers need a door
The client’s customers ask for status, documents, invoices, bookings — by email, today. A portal answers those questions without a person on the other end.
The product behind the service
A client wants to productize — turn the service into subscriptions, self-serve onboarding, usage dashboards. That’s an application with billing, and it gets scoped like one.
No-code hit its ceiling
The Bubble or Airtable build served well and now strains — permissions, performance, integrations. We rebuild on boring foundations, keeping what the prototype proved.
Example application builds.
Illustrative examples — the shape of work this line covers, not client case studies. Builds are quoted fixed-price from the published range ($8,000–$25,000 / build) before work starts.
Branded client portal
Usage dashboards, role-based access, document sharing, and Stripe billing — the client’s brand on the login screen, the client’s name on the accounts.
Operations dashboard
One screen replacing the Monday-morning spreadsheet ritual: live numbers from the systems the business already runs, with role-scoped views for the team and the owner.
Booking system
Scheduling, intake, reminders, and payment in one flow, shaped to how the business actually books — rather than how an off-the-shelf scheduler assumes it does.
How we build applications.
Application scope is written at screen level: what each role sees and does, the data model, and the acceptance criteria per milestone. Milestones land on dates in writing, progress arrives in your channel, and founder QA runs each build against the spec before you see it — behavior, edge cases, and security.
Handover is the point: the application deploys to accounts your client owns, handed over with docs — no license-back. From there, maintenance keeps it monitored and current, or your team takes it with everything they need.
The mechanics are the same on every line we ship:
- 01Pilot first — Every relationship starts with one real project: $1,000 flat, two weeks, fully credited toward month one of any retainer.
- 02Scoped in writing — Scope, milestones, and — on fixed-price work — the price, signed before work starts. The spec is the contract QA runs against.
- 03One point of contact — Javid scopes every project and answers inside four business hours; every active engagement gets a written status each Friday.
- 04Founder QA — Every deliverable is checked against the signed spec before you see it — behavior, edge cases, and security.
- 05White-label handover — Repos, credentials, and docs transfer to accounts you or your client control. Nothing we ship carries our name.
- 0690-day warranty — If a delivered build doesn’t match its signed spec, we fix it free for 90 days after handover.
Technologies
Defaults, not dogma — where your client already has a stack, we build in it.
- Next.jsApplication framework
- TypeScriptDefault language
- SupabaseAuth, Postgres, storage
- StripeBilling
- OpenAIScoped AI features
- AnthropicScoped AI features
Questions about web applications.
Whose designs do you work from?
Yours, if you have a design team — we build to your files. If you don’t, we work in a clean, unbranded UI system your designers can skin later. Brand design stays your side of the fence either way.
Who owns the code, and where does it run?
Your agency or your client, per your agreement — repos, infrastructure, and credentials in accounts they control, transferred fully at handover. Nothing about the deployment depends on us staying involved.
What moves a build inside the $8,000–$25,000 range?
Screens, roles, and integrations — the three real cost drivers. A single-role internal tool sits near the bottom; a customer-facing portal with billing and third-party integrations climbs. The scope shows the math before you approve it, and we scope first projects toward the bottom of the range.
Can you take over an application someone else built?
Yes, through the pilot: one fixed-scope project — an audit, a fix, a small feature — that lets us learn the codebase and lets you judge the work. If a rebuild is cheaper than a rescue, you’ll hear that in the scope, not after it.
Related service lines.
API integrations
Custom connections between the systems your clients already pay for — kept in sync with auth handling, retries, and idempotency.
Maintenance & support
A per-site care plan that keeps shipped systems running: monitoring, updates, small changes, incident response — under your brand.
AI chatbots
Assistants grounded in your client’s real content — support, internal knowledge, lead capture — with refusal scope and human handoff built in.
Start with one real build.
Scope your first project as the pilot — $1,000 flat, two weeks, fully credited toward month one of any retainer. If the work isn’t retainer-quality, you keep the deliverable and walk.