Forem: Saka Satish

Building Decision Systems That Know When to Say “No”

Saka Satish — Mon, 26 Jan 2026 05:09:17 +0000

Most software systems are designed to produce outputs.

Very few are designed to refuse.

In my experience, refusal is one of the hardest things to design — especially in systems that deal with money, performance, or growth.

*The problem with confident systems
*
Many decision tools assume a simple pipeline:

Ingest data
Compute metrics
Produce a recommendation

What’s often missing is a serious answer to:

What if the data shouldn’t be trusted yet?

When systems skip that question, they create false certainty.

And false certainty is dangerous — because it looks correct right up until it fails.

*Designing for uncertainty instead of outcomes
*
When I started building what eventually became MDU Engine, I made a rule for myself:

The system must be allowed to say “I don’t know yet.”

That single rule shaped everything:

Validation gates before any logic runs
Deterministic simulations for reproducibility
Explicit decision blocking when data windows are too short
Explanations focused on constraints, not prescriptions

This isn’t about being pessimistic.
It’s about being honest about uncertainty.

*Determinism over cleverness
*
One design choice that surprised people was avoiding probabilistic “magic”:

Same input → same output
Same data → same decision
Every run reproducible

Why?

Because decisions that can’t be replayed can’t be audited.
And decisions that can’t be audited shouldn’t move money.

*Why explainability matters more than accuracy
*
In practice, operators don’t just ask:

“Is this recommendation correct?”

They ask:

Why now?
What could go wrong?
What would make this safer next time?

If a system can’t answer those questions, accuracy alone doesn’t help.

*A quiet experiment
*
MDU Engine is intentionally small and conservative.
It doesn’t optimise.
It doesn’t automate.

It exists to make decision quality visible.

If you want to explore it or critique it, it’s live and public:

App: https://app.mduengine.com

Overview: https://mduengine.com

I’m less interested in adoption and more interested in discussion:

How should systems behave when uncertainty is high?

*Closing thought
*
We’ve built many tools that are good at telling us what to do.

We haven’t built many that are good at telling us:

“Not yet — and here’s why.”

I think we’ll need more of those.

Why HOLD Is a Valid Outcome: Designing Risk-Aware Decision Systems for Paid Media

Saka Satish — Fri, 16 Jan 2026 18:04:13 +0000

Most decision systems are judged by how confidently they recommend action.

Scale. Increase budget. Push spend.

But after years of working with paid media systems, I’ve learned something uncomfortable:

The most dangerous decision is not acting too late — it’s acting confidently on weak or unstable data.

This article is about why I believe HOLD is not a failure state in decision systems, but a deliberate and necessary outcome — especially when decisions involve real capital.

*The problem with optimisation-first systems
*
Most advertising and optimisation platforms are built around a simple assumption:

If performance looks good, scale.

Metrics improve → spend increases → system “works”.

But this logic hides several structural problems:

Short-term performance can mask volatility
Attribution signals are often noisy or incomplete
Small datasets exaggerate confidence
Automated systems rarely explain why they act

In practice, this means systems optimise movement, not safety.

As spend increases, the cost of a wrong decision grows exponentially — yet the decision logic often remains linear.

*Why uncertainty is not an error
*
One of the most common anti-patterns I’ve seen in decision systems is this:

If the system cannot decide, force a decision.

This usually results in:

aggressive heuristics
arbitrary thresholds
or “best guess” outputs

But uncertainty is not a bug.
It’s a signal.

A system that hides uncertainty behind confidence creates risk without accountability.

*Reframing HOLD as an intentional state
*
When designing a decision-support system for paid media capital, I deliberately treated HOLD as a first-class outcome, not a fallback.

HOLD does not mean:

nothing is happening
the system is unsure
the model failed

HOLD means:

the data does not justify irreversible action
the downside risk outweighs potential upside
volatility or drift makes scaling unsafe
the confidence interval is too wide

In other words, HOLD is the system saying:

“Proceeding would increase risk without sufficient evidence.”

That is not indecision.
That is restraint.

*Designing for risk before growth
*
Most AI-driven tools are optimised for performance improvement.

But when decisions involve money, risk modelling matters more than prediction accuracy.

Some principles that shaped my approach:

No decisions on insufficient data Small windows create false confidence.
Volatility blocks scale Stable averages can hide unstable distributions.
Confidence must be explicit A decision without confidence is misleading.
Human-in-the-loop by design Systems should support judgment, not replace it.

These constraints reduce the number of “decisions” the system makes — and that is intentional.

A decision system that always decides is not intelligent.
It’s reckless.

*Explainability is not optional
*
One of the biggest issues with optimisation platforms is that they produce outcomes without context.

Scale because the model says so.
Reduce because performance dipped.

But why?

If a human operator cannot understand:

what signals were considered
what risks were detected
what assumptions were made

then the system is not decision-support — it’s decision displacement.

Every outcome should be explainable enough to be questioned.

Especially HOLD.

*Auditability changes behaviour
*
When every decision is logged, versioned, and replayable, something interesting happens:

The system becomes more conservative
Assumptions become visible
Edge cases surface faster

Auditability forces honesty.

It prevents silent failures and overconfident heuristics.

In financial systems, audit trails are standard.
In advertising systems, they are rare.

That mismatch is a risk.

*Decision systems are not optimisation engines
*
One mental shift helped clarify this work for me:

Optimisation engines chase improvement.
Decision systems protect against irreversible loss.

Paid media sits uncomfortably between experimentation and finance.

Treating it purely as optimisation ignores the cost of being wrong.

*Closing thought
*
A system that confidently recommends SCALE on weak data looks impressive.

A system that says HOLD — and explains why — is often doing the harder, more responsible work.

In high-variance environments, restraint is intelligence.

If you’re building AI or decision-support systems in noisy, real-world domains, I believe designing for risk visibility, explainability, and restraint matters more than chasing clever predictions.

Building Privacy-Safe Attribution Pipelines: A Marketer’s Engineering Approach

Saka Satish — Fri, 31 Oct 2025 18:08:01 +0000

Every marketer has asked this question at some point: which campaign actually worked?
We pour budgets into ads, watch the dashboards light up, and then try to make sense of the chaos.
But over the past few years, that chaos has only deepened — cookies are disappearing, platforms report conflicting numbers, and privacy laws have changed how we can even measure success.

I’ve lived inside this problem for years. And somewhere between late-night data audits and conversations with developers, I realised something important:

To fix attribution, marketers have to start thinking like engineers.

The attribution gap nobody prepared for

The old, cookie-heavy world made tracking easy — but never accurate.
Third-party pixels followed users everywhere, and every platform claimed the same conversion.
Then came privacy updates, GDPR, and browser restrictions. Suddenly, marketers were half-blind.

Multi-touch attribution models collapsed because they depended on external identifiers.
Server-side APIs existed, but few teams had the technical muscle to wire them together.
As a result, reporting became fragmented, decision-making slowed down, and teams lost trust in their own data.

That’s when I decided to build a first-party attribution framework — one that respects privacy yet restores clarity.

Designing a privacy-first attribution framework

Here’s the simple idea: track less, but track better.

Instead of chasing every signal, I built a closed-loop system using tools most teams already have — GA4, Meta’s Conversion API, Consent Mode V2, and Looker Studio.

The workflow looked like this:

A visitor lands on the website. Consent Mode v2 records their preferences before any tag fires.

GA4 logs anonymised events with first-party identifiers.

Conversion APIs mirror those events to ad platforms using secure server-side calls.

Data flows into Looker Studio for unified visualisation.

Automations (Zapier / webhooks) clean, validate, and push qualified leads into the CRM.

Each component respected the user’s consent settings and avoided third-party dependencies.
The engineering wasn’t glamorous — debugging mismatched IDs and delayed events took patience — but when it started working, it felt like switching the lights back on.

The impact

After implementation across multiple clients and verticals, here’s what changed:

Attribution accuracy: +21 % improvement

ROAS: +28 % uplift

Reporting time: reduced from ~3 hours to ~30 minutes

Cost per acquisition: –18 %

Beyond the numbers, teams began trusting the data again.
They could finally connect ad spend to real conversions without guessing or over-counting.
And because users had a transparent consent flow, overall opt-in rates actually increased.

Privacy didn’t kill performance — it clarified it.

Privacy isn’t a blocker. It’s a blueprint.

Marketers often treat privacy as a constraint.
But when you design systems that earn consent and limit unnecessary collection, you get cleaner, more actionable data.

The future belongs to marketers who understand data architecture as much as messaging.
We don’t just optimise campaigns anymore — we architect reliable measurement ecosystems.
That shift in mindset is where true growth begins.

What others can do right now

If you’re still juggling inconsistent reports, start small:

Audit what you actually track. Cut redundant tags and keep only events that connect directly to business outcomes.
Move to a first-party event model. GA4 + Consent Mode V2 is a strong foundation; you don’t need custom code to start.
Automate responsibly. Use server-side APIs or tools like Zapier to send verified data — no need for invasive tracking.
Measure what matters. Replace vanity metrics with conversion efficiency and lead quality.

The transition isn’t overnight, but the moment your data becomes trustworthy, everything else follows — strategy, spend, and storytelling.

Closing thought
I’ve come to believe that the best marketers today are system designers.
They don’t just chase clicks; they build reliability into every dataset.

We’re entering a decade where marketing and engineering overlap more than ever.
And that’s a good thing — because when growth is measurable and ethical, everyone wins.

If you’re experimenting with your own first-party attribution setup or exploring privacy-ready analytics, let’s connect. I’m always open to trading notes and frameworks with fellow builders.

MarTech #Attribution #GA4 #Privacy #ConsentMode #PerformanceMarketing #Automation #Analytics #GrowthEngineering

Why Marketers Who Build Attribution Frameworks Will Shape the Next Decade of Growth

Saka Satish — Mon, 27 Oct 2025 11:38:36 +0000

I’ve spent the last few years working in performance marketing — not as someone just running campaigns, but as someone trying to build smarter systems around them.

Campaign budgets can get you reach, but in 2025, it’s not budget that wins anymore — it’s clarity.
And clarity comes from owning your data, attribution, and growth stack.

Most marketing teams still rely entirely on what platforms tell them. That used to work when tracking was simple, but privacy rules, signal loss, and platform automation have completely changed the game. If we keep treating campaign data as something we consume rather than something we own, we’re always going to be playing catch up.

That’s why attribution frameworks matter.
They turn marketing from guesswork into a data product.

🧭 The Real Problem: Marketing in a Black Box

When I talk to teams, I see the same three pain points over and over:

No single source of truth — GA, Meta, LinkedIn all tell different stories.
Privacy and cookie changes keep breaking tracking.
Automated campaigns give less transparency, not more.

In this environment, even good marketers make bad decisions — not because they lack skill, but because they’re working blindfolded.

🧠 What We Built: An Attribution Framework That Actually Works

A few years back, I started building an attribution stack for a mobility startup onboarding vendors and drivers.

Instead of leaning on one platform, we connected:

GA4 for clean event data,
GTM + Conversion API to capture signals beyond browser limitations,
Server-side processing to reduce data loss,
BigQuery + Looker Studio to make everything accessible to the business team.

The stack wasn’t fancy — but it was deliberate.
And that changed everything.

📈 What Happened Next

Once we shifted from platform-dependence to signal ownership:

📊 ROAS improved by 27%,
💰 CPL dropped by 18%,
⏳ Campaign decisions got faster and sharper,
🤝 Marketing finally spoke the same language as product and engineering.

We repeated the same framework for other verticals — e-commerce (KP E-Mart) and B2B SaaS (Candid8). The results were consistent: clear attribution leads to smarter growth.

🧰 Our MarTech Attribution Stack (Simplified)
User Event → GTM → GA4 + CAPI → Server Processing → BigQuery → Looker Studio

Data integrity: No more blind spots.
Control: No platform dependency.
Scalability: One framework, multiple campaigns.

What started as a “performance marketing solution” quickly became a growth architecture. And honestly, this is where the industry is heading.

🌍 Why This Matters

We’re entering a decade where marketers will have two choices:

Keep running campaigns inside black boxes,
Or build their own frameworks and shape how growth works.

I believe the next wave of marketing leaders won’t just be ad buyers — they’ll be growth architects who understand data flows, tracking, and tech stack design.

This isn’t about chasing the next big channel.
It’s about building strong infrastructure under every channel.

✨ Final Thoughts

I’m sharing this because I’ve seen how much can change when marketing stops reacting and starts engineering.

If you’re working in growth, product, or data — don’t wait for clarity to arrive from platforms. Build it.

The most impactful growth work isn’t hidden inside campaign dashboards — it’s happening in the systems we build around them.

Let’s make attribution smarter. 🧠⚡

🧑‍💻 Author:
Satish Saka – Performance Marketing & MarTech Strategist.
Focused on building attribution frameworks and growth infrastructure for high-performance campaigns.