Key takeaway
Want the short version? Skip down for a concise summary.
To build an enterprise web application, settle the stakeholders, systems of record, roles, and compliance needs before any code. Then choose a stack your own team can maintain, build in short iterations with working demos, test integrations against real systems, and end with a documented handoff your team can run. That is the order we follow in our enterprise web development work, and it is the order this guide follows.
It is written for product, IT, and operations leads who are planning a build and want to know what to decide first, what the architecture looks like, who needs to be in the room on each side, and what a clean handoff includes. Each step opens with the short answer, then explains the reasoning behind it.
What Makes a Web Application “Enterprise”
A web application is enterprise when it works inside an organization’s systems and rules instead of beside them. It reads from and writes to the systems of record, controls who can see and change what, leaves an audit trail, and is expected to keep running for years under a team that may not be the one that built it.
Size has little to do with it. A tool used by one department can be enterprise software if it touches the CRM, respects the identity provider, and has to answer an auditor’s questions. A large public website with no sign-in and no integrations is usually not. Five traits separate the two:
- Systems of record. The application connects to the CRM, ERP, identity provider, or data warehouse that already holds the truth, rather than keeping its own copy of everything.
- Role-based access. Different people see different records and can take different actions, and those rules are enforced on the server.
- Compliance and audit trails. Changes are logged with who, what, and when, and the history can be produced on request.
- A multi-year life. The business process will change, so the application has to change with it without a rewrite.
- An internal team that will own it. Someone inside the organization has to be able to run it, extend it, and explain it.
| Difference | Custom website | Enterprise web application |
|---|---|---|
| Main job | Attract, inform, and convert visitors | Run a business process for staff, partners, or customers |
| Users | Mostly anonymous visitors | Known, signed-in users with defined roles |
| Integrations | Forms, analytics, sometimes a CRM | Systems of record read and written in real time |
| Access control | Public pages and a small admin area | Role-based access down to the record and field |
| Lifespan | Redesigned when the brand changes | Expected to evolve with the business for many years |
| Who runs it after launch | The marketing team edits content | Internal engineering, IT, and operations teams |
Plan Before You Write Code
Settle six inputs before anyone writes code: who decides, which systems hold the truth, who may do what, what auditors expect, what data has to move, and how you will know it worked. The result is a written technical scope your steering group can review. That scope is also what makes “enterprise website planning” concrete.
What to settle before code
Six inputs that become a written technical scope
Input 1
Stakeholders and decision owners
Input 2
Systems of record
Input 3
Roles and permissions
Input 4
Compliance and audit
Input 5
Data and migration
Input 6
What success looks like
Output
Written technical scope
Reviewed by your steering group before architecture starts
Stakeholders and decision owners
Name the executive sponsor, the product owner, and the people in IT and security who can say no. Projects stall when approvals surface late in the build instead of at the start, so find out who signs off on identity, hosting, and data access before design starts.
Systems of record and integration points
List every system the application must read from or write to, who owns it, and whether a staging copy exists for testing. Integrations are where most surprises live, so each one gets a named owner and a described contract.
Roles and permissions
Write down every kind of user, what each can see, and what each can change. Treat roles as architecture, not a settings screen, because retrofitting access rules after the screens exist is where rework starts.
Compliance and audit needs
Decide what has to be logged, how long history is kept, and who reviews it. A note on each edit is light. A full point-in-time view of every record is a different build, and it should be a conscious choice.
Data and migration
Inventory what already exists in spreadsheets, legacy databases, and exports. Decide what moves, what is cleaned first, and what stays behind. Migration is rarely glamorous, but it decides whether users trust the new system on day one.
What success looks like
Pick the outcomes the steering group will judge the project by, in plain terms: a process that no longer needs a manual step, a report that no longer takes a day to assemble. If you want a head start on this step, our project blueprint turns these answers into a document you can share internally.
Choose a Stack and Architecture Your Team Can Run
Choose the stack your team can hire for and maintain in year five, not the one that is newest this quarter. For new builds we use TanStack Start and React with TypeScript, and Prismic where editors manage content.
The layers of an enterprise web application
Each layer has an owner and a contract
Layer 1
People and identity
SSO, roles
Layer 2
Interface
React, TanStack Start
Layer 3
Application and API
Business rules, role checks, audit log, OpenAPI and MCP
Layer 4
Integrations
CRM, ERP, identity provider, data warehouse
Layer 5
Data and hosting
Database, backups, Microsoft Azure
Observability · Security · Performance targets
Think in layers, and give each layer an owner and a contract. Our full tech stack page lists the specific tools, but the layering matters more than any single library.
Identity comes from your identity provider
Single sign-on with a provider such as Okta or Azure AD means people use the credentials they already have, and IT keeps control of who has access. The application consumes identity. It does not invent a second user directory.
Role checks live in the application layer
Hiding a button is not security. Every request is checked against the signed-in user’s role on the server, so access rules hold no matter which screen, API client, or script makes the call. The same layer writes the audit log, so every change records who made it and when.
Typed code from screen to database
TypeScript from the interface down to the API gives you one set of types across the stack. A relational database holds the records, backups are part of the design instead of an afterthought, and the whole system runs in a hosting environment such as Microsoft Azure that your IT team already understands.
APIs that people and AI agents can both call
Document the API with OpenAPI and expose the same capabilities through MCP, and the application is ready for the AI agents your organization will want to connect later. We explain why that is becoming table stakes in Agent-Callable APIs: Enterprise Table Stakes.
Write down the decisions
Architecture Decision Records are short notes that capture what was decided, what the alternatives were, and why. When a new engineer asks in year four why the system works the way it does, the answer is in the repository instead of in someone’s memory.
Who Does What: The Roles on Both Sides
An enterprise build needs named roles on both sides: your team owns goals, priorities, identity, and acceptance, and the build team owns engineering, design, and quality. A shared rhythm of demos and decisions connects them. Roles matter here, not résumés.
Who does what on an enterprise build
Roles, not résumés
Your team
Executive sponsor
Sets goals, clears blockers
Product owner
Sets priorities, accepts work
IT and security
Identity, network, compliance sign-off
Subject-matter experts
Real workflows, test data
Internal engineers
Future owners, pair during the build
Shared
Weekly demos and staging
Backlog priorities
Decision log (ADRs)
Build team
Senior engineers
UX/UI design
QA and accessibility
On your side
- Executive sponsor. Sets the goals and clears blockers that the project team cannot.
- Product owner. Sets priorities, answers questions quickly, and accepts finished work.
- IT and security. Own identity, network access, and the compliance sign-off.
- Subject-matter experts. Supply the real workflows and realistic test data.
- Internal engineers. The future owners. They pair with the build team during the project so nothing is learned for the first time at handoff.
On the build side
Senior engineers make the architecture decisions and write the code, UX and UI design shapes the screens around real workflows, and QA and accessibility testing run throughout the build instead of at the end.
What both sides share
Weekly demos on a staging environment, a single prioritized backlog, and a decision log. If the application has to show each role something different, such as the role-scoped views in an employee portal or intranet, the product owner and the subject-matter experts should see those views early, not at launch.
Build in Phases With Working Software
Build in six phases, with most of the effort in short iterations that each end in a working demo. We work in two-week iterations, so stakeholders see real software in their browser throughout instead of waiting for one big reveal.
How an enterprise build runs
Working software at every checkpoint
Phase 1
Discovery and stakeholder mapping
Phase 2
Architecture and ADRs
Phase 3
Iterative build
Phase 4
Integration, testing, and audit hooks
Phase 5
Handoff and enablement
Phase 6
Optional long-term partnership
Phase 3 up close
Two-week iterations, each with a working demo
- Iteration 1
- Iteration 2
- Iteration 3
Your sign-off
The phases mirror our process, with a few steps that matter more at enterprise scale.
1. Discovery and stakeholder mapping
The inputs from step two become the written technical scope. The steering group reviews it, and nothing is built until it agrees.
2. Architecture and decision records
The layers, integrations, and identity approach are settled and written down, with the first Architecture Decision Records in the repository.
3. Iterative build with working demos
Each two-week iteration ends with a working demo on staging, and the next iteration starts only after your sign-off. Scope changes are written down before any extra work begins, so nobody discovers a change at the end.
4. Integration, testing, and audit hooks
Integrations are tested against staging copies of the systems of record, never against guesses about how they behave. Audit logging, role checks, and accessibility are verified here with the people who will rely on them.
5. Handoff and internal enablement
Your engineers receive the repositories, documentation, and runbooks, and they work alongside the build team before the project closes.
6. Optional long-term partnership
Some teams take everything in-house. Others keep shipping improvements with us on a regular release cadence. Both are normal, and the choice is yours.
Plan the Handoff From Day One
A clean handoff means you own everything needed to run and change the application without us: the code, the infrastructure access, the documentation, and the knowledge. Plan it from the first week, because a handoff assembled in the last week is a handoff that is missing things.
What you should own at handoff
Planned from day one, not the last week
Repositories and infrastructure access in your name
Architecture docs and decision records
Runbooks and on-call playbooks
Test suites and accessibility evidence
Pair-programming sessions with your team
Path 1
Your team takes over
Everything above is in your hands, so your engineers can run and extend it.
Path 2
We keep it running
Annual hosting in our Microsoft Azure account, with support for the lifetime of the project.
By the end, five things should exist and be in your name: repositories and infrastructure access, architecture documentation with the decision records, runbooks and on-call playbooks, test suites with accessibility evidence, and pair-programming sessions your engineers have already sat through.
Path one: your team takes over
If you have an internal engineering team, they take the repositories and the runbooks and run the application themselves. The enablement work during the build is what makes this a transfer instead of a surprise.
Path two: we keep it running
If you would rather not staff it, we provide annual hosting in our Microsoft Azure account and support for the lifetime of the project. You still own the code and the documentation, so the choice is not a lock-in.
Which path fits depends on how much ongoing product work you expect and how large your engineering team is. We cover that decision in When to Hire an Agency vs Build an In-House Team.
What This Looks Like in Practice
In practice, these steps show up as role-scoped applications that replace spreadsheets, legacy systems rebuilt without losing their integrations, and platforms that carry real users every day. Here are four builds, each with a case study that has the full detail.
Alcon: revenue forecasting
Alcon’s internal sales teams forecast revenue in large shared Excel workbooks, where a single change could take 30 to 60 minutes to process. Working with their data science team, we built a real-time forecasting application with role-scoped data, so each person sees only their own records. Read the Alcon case study.
MJEC: internal app and client tools
MJEC coordinates 125+ manufacturers and partners. We built an internal application with role-based authentication and a complete change history for every edit, plus a public client tool that runs on the same authentication layer. Read the MJEC case study.
EZ Storage: modernizing a legacy system
We took over support of an ASP.NET 2.0 application that was more than fifteen years old, added a live integration with a third-party storage management API, then rebuilt the site on TanStack with that integration intact. Read the EZ Storage case study.
Performance Course: a high-volume platform
Performance Course runs registration, payments, and communications across multiple states, with more than 60,000 registered users. The work includes a staff console for operations and a separate parent app for families. Read the Performance Course case study.
Questions Teams Ask Before an Enterprise Build
How long does it take to build an enterprise web application?
It depends on scope, so we set the schedule after discovery rather than guessing up front. The work ships in two-week iterations, so stakeholders see working software in their browser throughout the build instead of waiting for one big reveal.
How much does an enterprise web application cost?
We don’t publish a number, because scope varies too much between projects. The biggest drivers are the number of roles and views, integrations with systems of record, compliance and audit requirements, data migration, and how many separate user-facing surfaces you need. Our guide to what drives the cost of a custom web application walks through each one.
Should we build it in-house or hire an agency?
For a one-time platform build or integration-heavy work, an outside senior team usually reaches a first deploy faster than staffing up. For ongoing, high-velocity product work, an in-house team is the right call. Our article on hiring an agency vs building an in-house team covers the full decision.
What stack should an enterprise web application use?
Choose a stack your team can hire for and maintain for years. For new builds we use TanStack Start and React with TypeScript, which give end-to-end type safety and deploy to Azure, AWS, or on-premise Node servers.
Can we modernize an existing system instead of starting over?
Often, yes. We assess the codebase first, write down what we found, and propose a scoped path. For EZ Storage we supported a legacy ASP.NET 2.0 application in production, then rebuilt it on TanStack without losing its live storage-management integration.
Who owns the code when the project is done?
You do. You get the repositories, infrastructure access, architecture documentation, and runbooks, so your team can extend the platform without us.
Do you host and support the application after launch?
Yes, if you want us to. We provide annual hosting and support for all of our projects, hosted in our Microsoft Azure account, with support for the lifetime of the project. If your internal team takes over instead, the handoff covers everything they need to run it.
Planning an Enterprise Build?
Tell us which systems the application has to connect to and who will use it. We will tell you what we would settle first, how we would structure the build, and whether we are the right team for it.
Start a conversation, see our enterprise web development work, or build a project blueprint.
Work With Us
Have a project in mind?
We build the web's most demanding applications. Let's talk about yours.