The Digital Project Stack

Before you build, it helps to know what you’re actually building.

A website can look like one thing from the outside. Behind it can sit a collection of different systems, accounts, connections and responsibilities.

Modern AI tools make the visible part of a project faster to create. The less visible layers still matter — especially when something changes, moves, disconnects or needs to be recovered.

This is an observation, not a rulebook. Some lessons only become visible through doing the work. A little prior understanding can make many of them easier to recognise before they become expensive.
The first distinction
“Build my website” is not one job.

It is a chain of separate responsibilities. Most of the friction appears where one responsibility hands over to the next.

ObservationThe tool is rarely the whole system.
A clearer way to see the project

Ten layers. Ten different questions.

Not every project will use the same technology, but the responsibilities tend to remain. Knowing which layer you are dealing with makes it easier to understand where a problem actually belongs.

01
Think

What are we actually trying to make, change or improve?

02
Build

What system creates the site or application?

03
Access

Who can get into the accounts, environments and services the project depends on?

04
Own

Where do the code, files, domain, data and administrative control actually live?

05
Connect

How do domains, DNS, databases, APIs, email and third-party services meet?

06
Deploy

Where does the public version run, and how does a build become the live version?

07
Verify

Is what is live really what was intended?

08
Protect

Could the project be recovered if part of the stack disappeared?

09
Cost

What continues costing money after the first build is complete?

10
Observe

What happens once real users, search engines and time begin testing it?

Layer 01
THINK

Start with the job, not the tool.

A familiar AI assistant can help shape an idea, question assumptions and turn a loose objective into something another system — or another person — can work from.

What outcome are we actually trying to create?
ObservationThe faster build tools become, the more valuable a clear brief becomes.
ChatGPTClaudeGeminiHuman judgement
Layer 02
BUILD

A working environment can feel like a finished website.

Modern platforms can make an idea visible very quickly. The page works. The design looks finished. Forms respond. That visible progress is useful — but it may still sit inside a temporary or platform-specific environment.

What feels complete

The visible product

Pages, forms, navigation, content and features appear to be working.

What may still be unresolved

The operational layers

Access, ownership, deployment, data, hosting, backups and recovery.

ObservationVisible progress and operational readiness are not always the same thing.
Layer 03
ACCESS

A project can depend on accounts nobody thinks about until access changes.

Domain registrars, hosting, repositories, databases, analytics, email, payment services and build platforms can all have separate logins and separate administrators.

If the person who set this up disappeared tomorrow, could the project still be managed?
ObservationAccess is not the same as ownership — but without access, ownership can be surprisingly difficult to exercise.
Layer 04
OWN

Where does the project actually live?

The answer may be different for the code, database, media, domain, email, analytics and administrative control.

ObservationA repository can feel like a backup. A domain can feel like the website. An account can feel like ownership. Those things overlap — but they are not interchangeable.
Layer 05
CONNECT

The gaps usually appear between systems.

A healthy website can still fail when the domain points somewhere else, an API key changes, a database connection breaks or authentication stops talking to the application.

DomainDNSDatabaseAPIAuthenticationEmailPayments
ObservationWhen one system ends and another begins, assumptions become expensive.
Layer 06
DEPLOY

A build and a live site are not necessarily the same thing.

Deployment is the handover between what was created and what the public actually receives. Hosting, environment settings, production builds, SSL, redirects, caching and the version being served all sit here.

Which version is actually live — and where is it running?
ObservationA build can be healthy while the deployment is wrong. A host can be healthy while the domain points somewhere else.
Layer 07
VERIFY

“It deployed” is not the final check.

Verification compares the public result with the original intention and checks whether anything unrelated changed along the way.

Public result

Does the live site work?

Not the preview. Not the development environment. The version a real visitor receives.

Original intent

Did the requested change happen?

And did navigation, forms, tracking, redirects, mobile behaviour or search visibility change unintentionally?

ObservationExecution without verification is only half a workflow.
Layer 08
PROTECT

Recovery is part of the project.

The useful question is not only “is it backed up?” but “could someone rebuild or restore the project from what exists?”

Worth knowing

What would be needed?

Latest code, data, domain access, credentials, configuration and a record of the services that need reconnecting.

Worth testing

Can it actually recover?

Can it be exported, restored and redeployed? Is there more than one point of access?

ObservationSome failures cannot be predicted. Recovery can still be planned.
Layer 09 · Cost Building is not the only cost. The first build is often the easiest cost to see. The stack continues after launch.
What continues

Small dependencies accumulate.

A digital project can carry recurring costs in several different systems. None may be large on its own, but they become part of the operating model.

Domain & hostingRenewals, production environments and storage
Platforms & subscriptionsBuilders, AI tools, plugins and services
APIs & infrastructureEmail, data, authentication, payments and usage
MaintenanceUpdates, fixes, monitoring and occasional intervention
ReworkThe cost that appears when an earlier assumption has to be rebuilt
ObservationThe expensive part is not always choosing the wrong tool. Sometimes it is discovering too late which responsibility the tool never owned.
Layer 10
OBSERVE

Launch reveals a new set of problems.

Real users, search engines, analytics, integrations and time begin showing things the build environment could not.

ObservationSome problems are unavoidable. Many are simply expensive to discover late.

The aim is not to eliminate mistakes. It is to recognise which risks can be reduced with a little knowledge before the next decision is made.

The practical takeaway

Systems help projects move forward.

But only when it is reasonably clear what each system is responsible for — and where the gaps between them still need to be filled.

Most people will learn some of this through their own projects. Some lessons will be unavoidable. Others can be made considerably less disruptive with a little prior understanding.

The Digital Project Stack
Think→Build→Access→Own→Connect→Deploy→Verify→Protect→Cost→Observe↻
The project does not end at launch. Observation feeds the next decision back into the stack.
CBOUND · DIGITAL PROJECT STACK An observation framework for AI-assisted digital projects.