We replaced spreadsheets with a real system (and it changed everything)

At some point, spreadsheets stop being helpful.

And start becoming your bottleneck.

That’s exactly what happened in our marketing operation at Ad Rock.

The problem wasn’t tools

We weren’t “disorganized”.

We had:

• structured spreadsheets

• clear workflows

• defined processes

And still, things didn’t scale.

The real issue was:

we had no system — only documents

What broke first

As we grew, we started seeing:

• duplicated work

• inconsistent campaign setups

• loss of historical decisions

• dependence on team memory

• lack of traceability

Every new client increased complexity non-linearly.

The key realization

The problem wasn’t execution.

It was architecture.

We were treating:

• briefings as files

• campaigns as sheets

• ads as text

Instead of:

• entities

• relationships

• state

The decision

We stopped trying to “organize spreadsheets”.

And decided to build a system.

Not a SaaS.

Not a product.

A system for our own operation.

The stack

We intentionally kept it simple:

• React + TypeScript + Vite

• Node.js + Express

• SQLite

• Session-based authentication

• Role-based access control

• Audit logging

No overengineering.

The hardest part (not what you think)

Building UI is easy.

Connecting APIs is easy.

The hardest part was:

defining the data model

From documents to entities

Before:

• a campaign was a spreadsheet

• a keyword list was a file

• performance was external

After:

• campaigns → entities

• keywords → entities

• ads → entities

• performance → entities

Everything connected.

What this unlocked

Once we had real state:

• we could track changes

• we could audit actions

• we could standardize execution

• we could automate safely

Authentication actually matters

Most internal tools fake auth.

We didn’t.

We implemented:

• server-side sessions

• permission-based modules

• controlled access per feature

Because:

internal tools without governance break at scale

Audit logs changed everything

This was unexpected.

Once we added audit logs:

• we could trace decisions

• we reduced operational errors

• we improved accountability

This alone justified the system.

AI belongs in the backend

We integrated AI (OpenAI) at the backend level.

Not in the frontend.

Reasons:

• control

• consistency

• security

• cost management

AI became a layer, not a feature.

What we didn’t do

We avoided:

• microservices

• complex infra

• premature scaling

• unnecessary abstractions

This is not a product.

It’s an operational system.

Current limitations

Still early in some areas:

• no full Google Ads API integration yet

• UI still evolving

• some workflows partially manual

But the foundation is solid.

What changed

Before:

• execution depended on people

After:

• execution depends on system state

The biggest lesson

Spreadsheets are flexible.

Systems are reliable.

And at scale:

reliability beats flexibility

Why this matters

If your operation depends on:

• Notion

• Google Sheets

• manual workflows

You don’t have a system.

You have distributed memory.

And that doesn’t scale.

What’s next

We’re evolving this into:

• Google Ads API integration

• automated campaign generation

• centralized analytics

• deeper AI integration

Final thought

We didn’t build software.

We built infrastructure for decision-making.

And that changed everything.

Full case (PT-BR)

👉 https://adrock.com.br/blog/ad-rock-sistema-interno-gestao-marketing