Software You Own, Not SaaS You Rent
Full-stack Django + React applications designed around your actual workflows. Internal tools, customer portals, operational consoles, admin dashboards — built to outlive the engagement.
We operate 14+ web properties on this stack
Common situations
Where This Shows Up
Six situations where custom software is the right answer. If you're here, off-the-shelf has run out of road.
Your "internal tool" is a Google Sheet held together with macros.
It worked when there were 50 rows. Now there are 50,000 and three people pray it doesn't break each morning. The right answer is usually a small purpose-built app — not a bigger spreadsheet, not a $40/seat SaaS.
Airtable hit its row limit. Now what?
Airtable is great until your data outgrows it, your workflows need real logic, or your team needs SSO and audit logs. We migrate from Airtable to a custom Django/Postgres backend that keeps your team's working patterns intact.
The SaaS you use is 80% there but won't customize the last 20%.
The vendor's roadmap doesn't care about your edge case. Customization through their plugin API costs $50K/year and breaks every release. Sometimes the right move is to leave the SaaS and own the workflow.
Your customers want a portal but you don't have one.
They ask for status updates, want to download invoices, need to submit support requests. You're handling each via email. A focused customer portal collapses this into a system where customers self-serve and your team only handles exceptions.
You have an ops team running the business on 15 browser tabs.
CRM, billing, shipping, support, inventory, analytics. Each in a separate tab. Each requiring its own login. Each holding 1/8th of the context for any given customer. An ops console pulls the relevant slice from each into one place.
You commissioned an app two years ago and now it's a mystery.
The original dev is gone. The README is one paragraph. Deploying takes a week of head-scratching. We take over inherited codebases — paid audit first, then either patch in place or rebuild what's broken.
Deliverables
What's Included
Every engagement ships with the same production-grade backbone. No part of this list is optional.
Discovery + scoped requirements doc
We interview the people who will use the app, map the workflows, and write a requirements document you sign off on before code starts. Most failed software projects fail at this step.
Architecture decision record (ADR)
Why Django, why Postgres, why this auth approach, why this hosting target. Written down so future-you (or your in-house team) can understand the choices we made.
Django + DRF backend
Strongly-typed models, REST API, admin interface (a free internal tool out of the box), test suite. The stack we've been shipping for a decade.
React + TypeScript frontend
Modern App Router patterns (Next.js when SSR matters; Vite SPA when it doesn't), Tailwind for styling, strict TypeScript throughout.
Postgres as the source of truth
ACID transactions, mature ecosystem, JSONB for the flexible bits, full-text search built in. Your data outlives the application; pick the DB accordingly.
Authentication + authorization
Email + password, SSO (Google / Microsoft / Okta), role-based permissions, audit logs. Set up correctly the first time so you don't redo it later.
Admin tooling
Django admin gives your team a back-office UI on day one. Custom dashboards on top where the operators need them.
CI/CD + automated tests
Buildkite or GitHub Actions. Tests gate deploy. Migrations run in CI. You can ship Friday afternoon and sleep Friday night.
Production deploy + monitoring
DigitalOcean, AWS, or your existing cloud. systemd or container-based. Sentry for errors, custom dashboards for the business metrics that matter.
Hand-off documentation
How to run it locally, how to deploy, how to operate. Written for your in-house team or the next firm to inherit it — not just for us.
Process
How We Build It
Five stages. The scope step matters most — most software projects fail at requirements, not at code.
Discover
Interview the people who'll use the app. Map the workflows. Identify the must-haves, the nice-to-haves, and the can't-be-there-on-day-ones.
Scope
Written requirements doc + architecture decision record. Fixed-price proposal with deliverables and timeline. Nothing starts until you sign off.
Build
Two-week sprints with working demos. You see real progress weekly, not a black box for 90 days.
Launch
Staged rollout: internal users first, then a pilot cohort, then full release. Each stage catches issues before they hit everyone.
Operate
30 days of operational support included. Optional ongoing retainer for iteration as your needs evolve.
Comparison
How We Compare
Three paths to a working application. Pick by how much you need it to fit and how long you need it to last.
Off-the-shelf SaaS
- Time to runningDays
- Workflow fit80%
- Customization ceilingHard
- Recurring costPer seat, forever
- Data ownershipVendor
- Vendor lock-inHigh
No-code (Bubble, Webflow)
- Time to runningWeeks
- Workflow fit90%
- Customization ceilingCapped
- Recurring costPlatform fees
- Data ownershipHosted
- Vendor lock-inMedium
Purcell Analytics
- Time to running8–12 weeks
- Workflow fit100%
- Customization ceilingYour code, no cap
- Recurring costHosting only
- Data ownershipYou, in your Postgres
- Vendor lock-inNone
Case study spotlight
Portfolio Command Center for Consulting
How Purcell Analytics built the Autonomous AJ Command Center — a Django + FastAPI + React platform that runs portfolio-wide content pipelines, GSC monitoring, financial dashboards, and continuous project-readiness audits across every site in the portfolio.
Industry
Internal operations platform
Company size
small consulting practice with 14+ properties
Stack
Django 5.2, FastAPI, React, TypeScript
Tech stack
The Stack We Build On
Mature, broad-talent-pool, well-documented. Your in-house team or the next firm should be able to operate this in years 3-5.
Backend
- Django + Django REST Framework
- Postgres (single source of truth)
- Celery + Redis (async work)
- Python 3.12+
- uv (fast, deterministic deps)
Frontend
- Next.js 16 (App Router, RSC)
- React 19 + TypeScript (strict)
- Tailwind v4
- Vite (for SPA dashboards)
- Zustand / TanStack Query as needed
Infrastructure
- DigitalOcean, AWS, GCP
- Doppler (secrets)
- Buildkite / GitHub Actions (CI/CD)
- systemd + nginx
- Sentry, Plausible, custom dashboards
FAQ
Frequently Asked Questions
Why Django + React and not Rails / Laravel / Node / Phoenix?
+
Django is a mature, batteries-included framework with the best admin interface in any ecosystem, strong ORM, excellent migration story, and a huge talent pool to hire from. React is the broadest frontend talent pool. The combination optimizes for code your future team can hire for and maintain — not for our novelty preferences.
Can you do mobile apps?
+
Web apps that work great on mobile (PWA, responsive design) — yes, always. Native iOS / Android (Swift / Kotlin) — not our specialty; we'll refer you to partners. React Native — if your roadmap genuinely needs a native app and you have the team to maintain it, otherwise the web version is usually the better business decision.
Will you sign an NDA before discovery?
+
Yes — standard. We routinely work under NDA and treat client information as confidential by default, NDA or not. See our privacy policy for our general posture.
Who owns the code?
+
You do, 100%. We deliver into your repo, your infrastructure, your servers. Your team can hire any other developer or firm to pick up where we left off without permission, fees, or strings.
What's your team structure?
+
Small senior team. Andrew Purcell is on every engagement as primary architect. We do not subcontract overseas or hide a junior team behind a senior face. The person scoping your project is the person building it.
What happens after you launch?
+
30 days of operational support are included for free — covers edge cases that surface under real load. After that, optional retainer for ongoing iteration, or you operate it with your in-house team. We've never held a client hostage with code only we can run.
Can you work with our existing developers?
+
Yes — common pattern. We architect + build the hard parts, your team handles ongoing feature work. We code-review PRs, mentor junior devs, and write documentation oriented for future maintainers.
What if our requirements change mid-build?
+
We expect them to. Two-week sprints + weekly demos surface change requests early. Small changes within scope are absorbed. Large changes get a written change order with revised price + timeline — no surprises on either side.
Related Services
More Case Studies
AACC Portfolio Command Center
Multi-tenant Django + React app managing 14+ web properties under one platform.
QuantAIze
AI-powered geocoding + analytics platform built on Django + custom AI pipeline.
Multi-Site Portfolio Hosting
Shared infrastructure pattern hosting multiple Django apps on a single droplet.
What Software Should You Own, Not Rent?
Schedule a 30-minute discovery call. You'll get a written recommendation on whether custom is the right call for your situation — and if not, who to call instead.