The traditional career path used to be clear.

You started as a junior data scientist, became senior, moved into management, managed larger teams, and eventually aimed for a director or VP position.

I don’t think this path is as obvious anymore.

Companies are becoming flatter, some middle-management layers are getting thinner.

Strong individual contributors are becoming more valuable.

We have all seen former CTOs move into IC roles at AI companies. For example, Workday’s former CTO recently joined Anthropic as a Member of Technical Staff.

This doesn’t mean that management is disappearing.

It means that middle layers are shrinking and companies are betting on builders.

We have entered the era of builders

Today, your ability to build and deliver something matters more than ever.

It is no longer enough to know how to train a model, write SQL, create a dashboard, or explain different statistical methods.

→ Can you take an ambiguous problem and turn it into something useful?

→ Can you understand what the business really needs?

→ Can you bring people together, make decisions, build a solution, launch it, measure its impact, and improve it?

→ Do you understand how to accelerate business growth - with or without AI?

This is what companies desperately need.

The strongest data scientists will be the ones who can combine data, engineering, product thinking, and AI to move a project from an idea to a real outcome , not just complete a small part of it.

Your technical skills still matter. But technical knowledge without ownership will become less valuable.

Get as close to AI as possible

One of the clearest moves you can make today is to get close to AI.

But being close to AI doesn’t necessarily mean becoming an AI researcher or training large language models ( though it’s a great place to be right now)

For a data scientist, it can mean:

• Building AI-powered products

• Designing evaluations for the AI features/agents

• Measuring their impact on users and the business

• Creating experimentation systems for AI products

If you receive a strong offer for a role closely connected to AI, especially at a company where AI is the core product, I would go for it.

But don’t follow the word “AI” blindly.

A role where you only maintain dashboards for an AI team may help you less than a non-AI role where you own important problems and build things from start to finish.

The real question is not whether “AI” appears in the job title.

It is whether the role gives you real ownership and helps you understand how AI is changing products, companies, and the way people work.

Learn to work with AI, not only use it

Almost everyone is using ChatGPT or another AI tool now. That alone is not a competitive advantage.

The advantage comes from learning how to reorganise your work around AI.

Can you use it to explore unfamiliar codebases, analyse data, build prototypes, write documentation, challenge your thinking, and complete projects that were previously too large for one person?

Do you know how to give AI the right context, connect different tools, design effective workflows, and understand where human judgment is still needed?

AI gives individuals much more leverage. In some cases, one person can now do work that previously required a small team.

But this also raises expectations.

If everyone can produce code and analysis faster, the value moves towards choosing the right problem, judging the quality of the output, and making the right decision.

As AI becomes stronger, your judgment becomes more important—not less.

Your company is not your identity

You are not your job title, and you are not the company you work for.

Companies change. Teams are reorganised. Managers leave. Strategies shift. Roles that look safe today may disappear tomorrow.

Read more

At the beginning, the path is obvious.

Learn SQL. Learn statistics. Get comfortable with Python. Understand experiments, models, data pipelines and production systems.

Then you become senior.

You can still find gaps.

In fact, you can find an unlimited number of them:

1. causal inference

2. LLM evaluation

3. Bayesian methods

4. Spark

5. Kubernetes

6. a new vector database released last Tuesday

7. another LLM framework

There is always another subject that can make you feel slightly behind.

But another technical course or simulator rarely change the kind of work you are trusted with.

Obviously abmarks.io is an exception and it will change the kind of work you are trusted with

It might make you better at solving a particular problem. It will not necessarily make you better at finding the right problem, getting people to act on your work or helping your company make better decisions.

That is the real shift after senior.

6 month ago, a colleague asked me:

“I am senior now. Great. What is left to study?”

I have been thinking about that question ever since. Here is what I think matters next.

Learn to choose the problem

A competent data scientist can answer a question.

A strong senior data scientist notices that the question is wrong.

“Can we predict which users will churn?” sounds reasonable. But the useful question might be:

Which users can we realistically retain, with which intervention, and at what cost?

The second question changes everything. It affects the target, the evaluation metric, the data you need and whether a model is useful at all.

At this level, the work is no longer just about choosing methods, validating data, and defining metrics. It is about judgment, priorities, and making decisions when the answer is not obvious.

A simple habit helps: before starting an analysis, write down five things.

• What decision will this work support?

• Who will make it?

• What are the available choices?

• What evidence could change the decision?

• What happens if we are wrong?

When these questions have vague answers, better modelling will not save the project.

Understand the whole system

Senior data scientists usually understand models.

The next step is understanding everything around the model.

• Where did the data come from?

• What behaviour generated it?

• How does the output enter a product or workflow?

• Who monitors it?

• What happens when it fails quietly?

The model is only one part of the work. Often, it is not even the most important part.

Choose one important metric or model in your company and trace it from beginning to end:

• how the raw event is produced;

• how it is transformed;

• where assumptions enter;

• how the result is presented;

• which action follows;

• who notices when it is wrong.

You will probably learn more from that exercise than from a general course on “advanced machine learning”.

Learn to make decisions with incomplete information

Earlier in a career, ambiguity often feels like a problem that someone else should remove.

Later, ambiguity is the work.

You will rarely have the sample size you wanted, a perfectly stable metric and six months to investigate. You will have three imperfect sources, a deadline on Friday and a stakeholder asking what you recommend.

The skill is not creating certainty. It is making uncertainty clear.

A useful senior answer often sounds like this:

Here is what we know. Here is what we are assuming. Here is the risk in each option. Given that, this is what I would do.

Keep an assumption log for important projects. Separate reversible decisions from expensive ones. Agree on failure criteria before seeing the results. Say what additional information is worth collecting, and what is unlikely to change the decision.

Knowing when to stop analysing is part of statistical judgment too.

Learn to influence without becoming unbearable

Data does not speak for itself.

Good analysis is not enough. Someone still has to explain why it matters.

Many technically strong data scientists discover this late. They produce correct work and assume that correctness should be enough. Then a weaker analysis wins because it is attached to a clearer story, a trusted person or a decision people already understand.

The most valuable learning rarely comes from a famous person giving a broad lecture. It usually comes from two experienced people discussing a real problem and being honest about what happened..

Influence does not have to mean manipulation. Usually it means doing the unglamorous work:

Read more

Open ChatGPT. Explain the problem. Paste some context. Get an answer. Copy it somewhere. Close the tab.

Next day, do it again.

That was me for a long time. The answers were useful, but the process was still annoying. Every session started from zero, and I was the one carrying the context.

This works for small tasks.

It breaks down for real data science work, because real DS work has memory.

You need to remember:

→ which table has the correct metric

→ which stakeholder asked for which cut

→ which analysis version was trusted

→ which caveat matters

→ which meeting changed the direction

→ which experiment had logging issues

→ which dashboard is outdated but still used by leadership.

A lot of data science is not writing code. It is carrying context.

So my goal became simple:

Stop re-explaining my work to AI.

Below is the setup I use across personal and work projects.

1. Second Brain — the foundation

The most important part of my setup is a structured workspace.

I have seen many people and companies already call this kind of system a Second Brain, so why not keep the same name?

It is a set of files that describe my active projects, stakeholders, metric definitions, useful links, decisions, notes, and recurring workflows.

I organize it roughly using PARA:

• Projects

• Areas

• Resources

• Archives

It lives in Google Drive, so it survives across machines and sessions. The key part: my AI coding assistant can read it when I start working.

So instead of saying:

Here is the background, here are the tables, here is the metric definition, here is what happened last week

I can say:

Continue the campaign performance analysis. Check if the WoW change still holds after excluding market B.

That is a very different interaction. The AI is no longer starting from a blank page.

What I keep inside

For each active project, I usually keep:

• project goal

• current status

• main stakeholders

• important links

• table names

• metric definitions

• known caveats

• decisions already made

• open questions

• next steps

This is boring.

Boring is good.

Most productivity systems fail because they try to be too clever. This one works because it is just structured context.

The compounding effect is real. Every time I save a note, capture a decision, or update a project file, the next session gets better. After a few weeks of feeding it, you stop noticing the setup cost — you just describe what you need and it happens.

One thing I got wrong early: I kept stuffing everything into one big context file. It grew to 700+ lines and actually made the agent slower and less focused. What works better is a layered approach — a slim top-level file that points to deeper context, loaded only when relevant.

2. Claude Code — the hands

Second Brain is the memory. Claude Code is the hands.

For me as a data scientist, this means: writing and iterating on SQL, building analysis scripts, generating reports, editing documents, creating presentations. It’s not a chatbot — it’s a coding partner that lives in my terminal and can reach into my file system.

The way I use it most: I’ll describe an analysis I want to run — say, “I need to understand the week-over-week trend in campaign performance across these three markets, broken down by format” — and Claude Code will write the query, run it, iterate if something looks off, and produce a structured output. I steer, it executes.

Where this really shines is when the analysis isn’t a one-liner. Anything that involves multiple tables, joins, validation steps, or formatting into a deliverable — that’s where the autonomous loop saves me hours. I used to spend a full afternoon on what’s now a 20-minute conversation.

I also use it for things that aren’t strictly “data science” — writing documentation, drafting comms, structuring my thoughts into something coherent. It’s become the default interface for anything that requires sustained thinking plus output.

3. Wispr Flow — capturing thoughts before they disappear

This one sounds trivial but genuinely changed my workflow.

Wispr Flow is voice-to-text.

I speak, it writes.

Why does a data scientist need voice-to-text? Because my best thinking doesn’t happen at the keyboard.

I use Wispr to:

• Save thoughts in transit. Walking between meetings, on the tube, making coffee — ideas come and I used to lose them. Now I speak them into a note and they’re captured. I have a running “thoughts” doc that I periodically feed back into my Second Brain.

• Write richer prompts. When I’m describing a complex analysis to Claude, speaking naturally produces way more context than typing. I’ll ramble for 30 seconds about what I actually want, and the prompt comes out better than anything I’d type.

• Draft first versions of documents. Instead of staring at a blank page, I talk through what I want to say. The structure is messy, but the ideas are there — then Claude cleans it up.

• Process meetings in real-time. Right after a meeting, while context is fresh, I’ll dictate my takeaways and action items. Thirty seconds of talking captures what would otherwise evaporate by the time I sit back down.

The speed difference matters more than you’d think. Speaking is 3-4x faster than typing, and for some reason it’s also more honest — I say what I actually think instead of self-editing as I type.

4. MyClaw — the always-on watcher

MyClaw is my always-on agent. It monitors things I care about and surfaces them without me having to go looking.

The setup: I’ve configured it to watch specific chat channels, track mentions of topics I care about, and generate periodic summaries. Think of it as a personalized news feed for my work context — but instead of me scrolling through hundreds of messages, it distills what matters.

I get:

• A daily digest of what happened in key channels while I was offline or in meetings

• Alerts when specific topics come up (project names, metric names, stakeholder names)

• Weekly summaries that help me draft my own updates

It’s not glamorous. It’s not even particularly “smart.” But it solves a real problem: I was spending 30-40 minutes a day just reading to stay in the loop. Now the staying-in-the-loop happens in the background, and I get a 2-minute summary instead.

5. NotebookLM — the research partner for messy, multi-document problems

NotebookLM is Google’s tool for reasoning over a collection of documents. You upload sources — PDFs, docs, web pages — and it lets you ask questions across them, synthesize, compare, find contradictions.

I use it for two very different purposes:

Work: synthesizing domain research. When I’m scoping a new analysis area or trying to understand a complex business question, I’ll throw 10-20 relevant documents into NotebookLM — past analyses, strategy docs, meeting notes, industry reports — and have it build me a structured understanding. It finds connections I’d miss reading sequentially, and it cites everything so I can verify.

Personal: my Global Talent visa application. This is the use case that sold me on the tool completely. The UK Global Talent visa requires you to demonstrate “exceptional talent or exceptional promise” in your field. The application involves pulling together evidence from multiple sources — publications, reference letters, proof of impact, immigration guidelines, successful application examples.

I uploaded everything:

→ the official government guidance

→ successful application examples I found

→ my own CV

→ reference letter drafts

→ proof of work documents

→ relevant immigration forum threads.

Then I used NotebookLM as my research partner — asking it things like “what evidence do I have that maps to criterion X?”, “what gaps exist in my application compared to successful examples?”, “how should I frame this achievement in the context of the guidance?”

It’s essentially a research assistant that holds a hell of a context at once and lets you have a conversation with it. For any multi-document problem where the answer lives between documents rather than in any single one, it’s an awesome tool.

6. Zapier / n8n — the glue and the automations

The last piece is automation. Zapier (and more recently n8n for things I want more control over) connects everything together and handles the recurring stuff.

Read more

You installed the tools. You watched the tutorials. You set up the workflows people on Twitter swear by. And then you actually tried to use AI for real work - your work - and it gave you something wrong. Not slightly wrong. Confidently wrong.

So you corrected it. It went in circles. You corrected it again. It hallucinated a table that doesn’t exist. You tried one more time, then closed the tab and thought:

I could’ve done this in half the time myself.

You’re not wrong. You probably could have.

But here’s what nobody tells you: that moment - the one where you want to quit - is the most expensive moment to quit.

The New Hire

Imagine you hired someone brilliant but brand new. Day one, they don’t know your systems. They don’t know that when your team says “the dashboard,” they mean one specific dashboard. They don’t know that the column called revenue in your table actually means gross revenue and there’s a totally different field for net. They don’t know that your manager hates bullet points.

Would you fire that person after three days because they asked obvious questions? Of course not. You’d invest in onboarding them. You’d correct their mistakes, explain the context, and expect them to pick it up over time.

AI is that new hire. Except most people fire it after day two.

Why the First Week Feels Broken

The thing that makes AI frustrating at the start is the same thing that makes it powerful later: it adapts to context. But context doesn’t exist on day one. You have to build it.

When you first use AI on your real work, it’s operating with zero knowledge of:

• Your specific data (what tables exist, what columns mean, what’s stale)

• Your conventions (how your team names things, what “done” looks like)

• Your preferences (how you like explanations structured, what level of detail you want)

• Your domain (the unwritten rules that everyone on your team knows but nobody’s documented)

So it guesses. And guesses from a general-purpose model applied to a specific-purpose problem will be wrong. A lot. That’s not a bug. That’s the starting line.

The Mistake That Costs People Months

Here’s what most people do:

1. Try AI on a real task

2. Get a mediocre or wrong output

3. Conclude “AI isn’t there yet for my work”

4. Go back to doing it manually

5. Try again in six months, repeat from step 1

Every time they restart, they’re back at zero. No context was saved. No corrections were captured. The AI they come back to is exactly as clueless as the one they left.

Meanwhile, the people who are getting scary-good results from AI did something different. They didn’t have better tools or more technical skill. They just didn’t quit after step 2.

The Flywheel Nobody Sees

Here’s what “sticking with it” actually looks like in practice:

You finish the task. Even when it’s painful. Even when you’re correcting the AI five times. Even when doing it yourself would’ve been faster. You finish because the output isn’t the point - the corrections are the point.

Every time you say “No, not that table - use this one,” that’s a piece of knowledge. Every time you say “That’s the wrong metric definition, here’s the right one,” that’s a lesson. But a lesson only has value if you write it down somewhere the AI can find it next time.

Read more

The product I’ve been working on for quite a while is now live.

I’ll share more about how I realized there was a real need for this product. The A/B testing and causal inference domain is unique when it comes to the learning curve.

The foundations are everywhere: t-tests, z-tests, what A/B testing is, statistics basics.

But when it comes to truly understanding experimentation and working on real projects, so many questions start to appear — and most answers are scattered across years of practice, discussions with other practitioners, standalone blog posts, or academic papers that are very hard to find.

Questions like:

• How does randomization actually work in A/B testing?

• How can we run many experiments in parallel?

• How do we measure long-term impact?

• Is there a way to bundle multiple experiments for one feature and get a more precise answer?

• What actually happens when randomization and analysis units are different?

• Why do we need geo testing or cluster testing?

And there’s an endless number of questions like these.

I couldn’t find one place where I could learn all of this, practice it, and start applying it confidently.

Now there is one: ABmarks.

If you go through every lesson and every exercise, you’ll be ready for experimentation interviews, ready to deliver real insights from experiments, ready to work with complex experimental designs, and — what I think is most important — ready to validate assumptions, results, and experiments properly.

For subscribers of my newsletter, I’m sharing a discount for the first two weeks:

LAUNCH2026

Meanwhile, I’ve already started working on a fully practical module for the platform — where people with zero experience can get everything they need to become successful in experimentation, and people with strong exposure can sharpen their skills by working on a variety of real-world designs.

The difference usually comes down to how you interact with it.

I have tried to accumulate the main hints that can make your “AI data science” workflow flow significantly better.

The Core Workflow Patterns

1. Your Context File is Everything

The single most impactful move you can make is to maintain a small, always-updated context file that the AI can read at the start of a session. You can call it AI_CONTEXT.md or PROJECT.md.

A good context file ensures the AI knows your role, domain, and constraints. It stops you from repeating yourself each session and ensures outputs match your standards for SQL dialects, naming conventions, tone, and statistical assumptions.

How to start:

Include your role and domain, your data stack at a high level (warehouse, notebook, BI), your default assumptions (time zones, definitions, experiment conventions), and a few things you repeatedly ask for.

Example bullets to include:

• I am a data scientist working on growth questions.

• Default SQL dialect: Snowflake. Prefer CTEs; avoid vendor-specific functions unless asked.

• Lead with the business implication, then show the analysis.

• Challenge my assumptions before agreeing.

• When I say ‘experiment’, assume: primary metric, guardrails, segmentation, power/significance checks.

2. Be Painfully Specific About What You Want

Treat the AI like briefing a new teammate. Taking 30 seconds to provide context upfront saves 15 minutes of back-and-forth.

❌ Bad:

“Help me with this experiment.”

✅ Better:

“Evaluate experiment X. Focus on segment Y. Show metric Z by country and platform. Include significance, effect sizes, and a sanity-check section (SRM, sample ratio, missingness). Return a 6-bullet executive summary plus a table.”

3. Ask for the Approach Before the Answer

This catches wrong assumptions early before the AI writes any code.

Example:

Before you write any SQL or code, propose: • The dataset(s) I likely need • The join keys and grain you will assume • The edge cases to verify • 2–3 validation queries you would run first

4. Prefer Multi-Turn Collaboration Over One-Shot Prompts

Do not restart from scratch for every question. Build a thread where each turn carries context you do not have to restate. The compounding effect is real.

• Step 1 “Help me identify candidate tables and grains.”

• Step 2 “Now draft the query and sanity checks.”

• Step 3 “Add segment breakdowns and moving averages.”

• Step 4 “Turn results into a readout and caveats.”

5. Specify Output Format

If you need something pasteable, say so explicitly.

Return:

1. A 5-bullet executive summary

2. A markdown table with: metric, control, test, delta, delta_pct, p_value

3. A “Checks” section (SRM, missing data, outliers)

6. Do Not Fight the Model — Guide It

Read more

I think an essential part of the answer lies in one core competency: Analytical Rigor.

When you check on LinkedIn, 80% of data roles will have this requirement everywhere, but what does it actually mean?

What is Analytical Rigor?

Let’s start with what it is not.

Analytical rigor is not about applying the most complex math possible. It is not about achieving absolute certainty or perfection.

Instead, it is about ensuring that the entire analytical process is sound, logical, and defensible. It involves several key practices:

• Solving the Right Problem: Finding the right questions and answering them. You can execute a flawless analysis, but if it doesn’t address the core business challenge, it is useless.

Example: A product manager asks for a "quick data pull" of how many users clicked the new 'Share' button this week. Instead of just running the SQL, a rigorous analyst asks: "What decision will this number drive?" If the goal is to measure feature success, the analyst might suggest looking at the retention of users who shared, rather than just a raw click count.

• Applying the Best Methodology: Using the highest quality measurement and analytic techniques available for the specific problem.

Example: Choosing a causal inference method like Difference-in-Differences when you need to understand the impact of a marketing campaign, rather than just looking at simple pre/post correlations.

• Relying on Trustworthy Data: Verifying that the underlying data is accurate, reliable, and that the processes generating it are sound.

Example: Before analyzing user engagement, checking for duplicate tracking events or missing data from a recent app release.

• Validating Results: Cross-checking your findings. This means looking at the problem from multiple angles to see if the conclusions hold up.

Example: You see a sudden spike in daily active users (DAU) in your internal dashboard. To validate this, you triangulate: do you see a corresponding spike in server load logs? Do third-party analytics tools (like Google Analytics or Mixpanel) show the same trend? If the internal dashboard says traffic doubled but server load remained flat, you likely have a logging bug, not a growth spurt.

• Acknowledging Constraints: Clearly calling out assumptions, caveats, and unknowns.

Example: Stating upfront, “This analysis assumes that user behavior during the holiday season is representative of the rest of the year, which may not be true.”

Ultimately, your analysis should be reproducible and robust. If someone else (or you, six months from now) runs the same analysis on the same data, they should reach the same conclusions.

Why Does It Even Matter?

Rigor is what turns a quick data pull into a decision that actually moves the business. Without it, you are just handing someone a number. Therefore, it provides several crucial benefits:

• Improving Your Likelihood of Success: Teams don't have to rely on instinct. They have something concrete to act on — and that changes the quality of the decision entirely.

Read more

Not long ago, a data scientist’s day was consumed by writing SQL queries, tuning models, and running experiments. Today, thanks to AI, a single data scientist can do the work of an entire cross-functional team. They are writing production code, building end-to-end systems, driving business decisions, and solving complex problems without waiting on anyone else.

This isn’t just a trend at a few big tech companies; it is happening everywhere. AI tools are democratizing capabilities that traditionally required armies of engineers and product managers.

For data scientists today, the question is no longer if our jobs will change, but how we will adapt.

Why the Old Way is Breaking Down

In the past, the data science workflow was linear and slow. A data scientist found a problem, wrote queries, built a model, and then handed it off to an engineer to put into production. Next came designing an experiment, running it, analyzing the results, and deciding whether to scale up or pivot. Every single handoff introduced friction and delays.

Now, AI tools are eliminating those bottlenecks. A data scientist can use an AI agent to identify an issue, trace it back to the source code, and deploy a fix—all without waiting for an engineering ticket to be picked up.

This doesn’t mean AI is replacing humans. It means AI is amplifying us. When AI can write SQL, generate charts, and draft boilerplate code, the most valuable skills shift from syntax memorization to big-picture thinking and strategic execution. We are moving from merely analyzing data to actively building solutions.

Based on this shift, I see three distinct archetypes emerging for how data scientists are adopting AI.

1. The Systems Data Scientist

These are the foundational builders. They ensure that a company’s data infrastructure is organized, clean, and structured so that AI tools can actually understand and utilize it effectively.

If an AI agent is fed messy, unstructured data, it will confidently deliver bad answers. The Systems Data Scientist prevents this. They create the rules, semantic layers, and governance structures that allow AI agents to operate quickly and accurately.

What they do:

•Structure and organize data pipelines so AI models can easily ingest and interpret the information.

•Design robust testing frameworks to validate that AI tools are generating accurate and reliable outputs.

Read more

If you want to stay sharp, you need to become an AI experimentalist.

Over time, I’ve realized there are 6 habits that will help you succeed with AI in the long run.

1. Schedule 30 minutes for AI practice

If you don’t practice, you won’t get good at this.

Block 30 minutes a day, 1 hour a week, or whatever cadence works. Think of it like an AI gym session: low pressure, high reps.

The key: don’t just passively read about AI - use it.

Try something small:

• rewrite a query

• debug an error

• summarize a notebook

• generate a chart explanation

• test a new tool

Once you’ve built some momentum, experiment with tool chaining: multiple AI tools working together for one outcome. For example:

• analyze data → gather context → draft slides → refine narrative

Over time, you’ll build instincts for when AI is helpful - and when it’s guessing.

2. Use AI to learn, not just to execute

AI isn’t just there to write code. Use it as a tutor.

Ask it to:

• Explain a pipeline.

  • “Read through this pipeline thoroughly and give me a summary of what it does, which data sources it uses, and how the output is structured.”
    It almost always beats reading the pipeline code line by line.

• Understand the metric definition.

  • “Trace the data lineage for this signal and tell me where it originally comes from.”
    It will follow the joins, upstream tables, and transformations — and often give you a clear answer.

• Explain some of your teammates works.

  • Point it to an existing notebook or query and ask it to walk through the methodology.

And don’t forget the follow-ups.

“What assumptions are you making?”

That one question alone can surface hidden problems.

3. Give context, not just instructions

I believe this is the most common advice - and at the same time, the most important.

AI is smart, but it doesn’t know your business.

That’s your biggest lever.

You wouldn’t throw a new hire or even an experienced one into a project with zero context and expect amazing output. Same thing here.

If you ask AI for “conversion rate,” it has no idea what that means in your company unless you explain it.

So give context:

• Describe your tables and how they connect

• Share the business processes behind the data and what you’re actually working on

• Define your metrics (numerator, denominator, filters, time grain)

The more context you provide, the better the output. Vague prompts = vague answers.

Pro tip: use suggestive language over rigid commands.

Read more

Most of them are either vague, too general, or just didn’t work for me.

Over time, I found a few simple habits that actually do. Nothing fancy, no magic tricks — just small things that compound.

Here’s what helped me stay sharp and useful.

Keep a brag doc

I’ve shared this already on LinkedIn, but it’s still the most powerful hint that helps me along the way.

Make a private Google Doc.

Drop in:

• wins

• feedback

• projects you shipped

• moments when you helped someone out

• interesting challenges

You will forget this stuff faster than you expect. I personally forget it in a week max.

Then performance review season comes, or impostor syndrome kicks in — and suddenly your brain is empty.

That doc becomes pure gold.

Just try it for at least 3 months and you’ll see the difference.

If you actually want to remember things — teach them

That’s my favourite.

Who actually remembers how algorithm X works if you don’t prepare for interviews?
Not me, at least.

Start teaching.

Nothing locks knowledge in like explaining it to another human, especially right after you learned it yourself.

It works for everything:

• fundamentals and math

• ML concepts

• interview prep

• honestly, almost anything

Teaching forces you to organize your thoughts. It shows you where you’re fuzzy. Stuff moves from short-term memory into long-term storage.

Run demos. Even if nobody asked for them.

If your team doesn’t do demos or knowledge sharing — just start.

Keep it casual. Internal only. Let people show what they’re working on. Most teams have more projects than people, so this quickly creates shared context.

I like having at least one short presentation per project:

• first inside the team

• later for a wider audience

• optionally summarized somewhere internal

A few nice side effects:

• everyone knows who’s doing what

• random connections pop up (“oh, we tried something similar”)

• onboarding gets way easier (new folks can skim slides instead of pinging 10 people)

Small habit, big payoff.

And like every habit, it’s hard to maintain — but it’s really powerful.

Build

Most data people get dragged into endless meetings, docs, exploratory analysis, etc.

If you don’t build, your skills become rusty. Maybe in 2 months, maybe in 5 months, maybe in a year — but the outcome is inevitable.

You can build a small system for manual file uploads, or new data pipelines to automate part of your job. Or a self-service dashboard to analyze your meetings.

I personally build something once a month as a rule. It may be very simple, but it helps me keep my skills clean.

And now with vibe coding, it’s easier than it’s ever been.

Random Coffee

You come to a new place. Your circle is limited: you have your team, your XFNs, your stakeholders — and that’s mostly it.

But what happens if you randomly reach out to a Data Engineer in a completely different team? Or a Data Scientist from a totally different company?

Most interesting connections don’t come from formal networking events or work projects. They come from random space.

A simple loop:

• find people doing work you’re curious about (coworkers, LinkedIn, Twitter, meetups, Substack, GitHub — anywhere)

• send a short, friendly message

• find a bit of common ground

• suggest a quick coffee or virtual chat

No pitch. No agenda. Just curiosity.

Something like:
“Hey — I saw your work on X. I’m also into Y. Want to grab a 20-minute coffee sometime?”

You’ll be surprised how often people say yes.

Over time, this compounds:

• you learn what’s actually happening across teams and companies (not just what’s in Slack or blogs)

• you start seeing patterns

• you connect people who should probably know each other

• opportunities surface earlier

• your name starts popping up in places you’re not even in

I’ve met a lot of great and interesting people this way.

Don’t limit yourself to just my approach. Do your own experiments.

Something that works for me may not work for you.

Explore.

Here I will share some of the best practices to ensure your experiments yield reliable, actionable insights.

1. Always Focus on a Measurable Hypothesis

Before you start, clearly define what you want to test. A strong experiment begins with a specific, testable hypothesis that can drive future improvements. Your train of thoughts should go from the general question to the specific hypothesis. For example:

• General question: “Does changing the price affect sales?”

• Refined question: “Does lowering the monthly price from $29 to $25 increase conversions?”

• Specific hypothesis: “Lowering the price to $25 will increase conversions by at least 10% because the users are susceptible to the price.”

A good hypothesis answers three things:

• What are you changing?

• What metric should move?

• How much do you expect it to change?

The best hypotheses answer an additional one:

• Why should it work?

If you can’t answer those, you’re not running an experiment - you’re just vibes-testing.

2. Don’t Rerun Experiments Until You “Win”

Running the same experiment multiple times until you get a statistically significant result is a form of p-hacking.

If your experiment failed:

• Figure out why

• Improve the hypothesis

• Fix the design

• Then try again

Fishing for a better p-value doesn’t make the result real.

3. Don’t Cherry-Pick Dates or Stop Experiments Early

Selecting dates or stopping experiments based on when results look favorable introduces bias and reduces reproducibility.

Best practices:

• Define objective criteria for experiment duration and data inclusion before starting.

• Set clear pre-defined stopping rules (especially for detecting degradation)

• Avoid peeking at results unless using really principled adaptive methods.

4. Don’t Equate “Not Statistically Significant” with “Neutral”

A “not statistically significant” result does not mean there is no effect, it only means the experiment didn’t detect an effect with high confidence.

Why this matters:

• The absence of evidence is not evidence of absence.

• Small samples and noisy data can hide real changes

• Tiny negative undetected effects can accumulate over time. Run enough of them, and you’ll see real degradation.

  • Simple rule here helps. Check that the lower boundary of your confidence interval is above your threshold for regression. For example, to be 95% sure you haven’t lost more than 0.5%, the lower bound should be above -0.5%.

5. Don’t just “explore” the data

When it comes to the measurement of the experiment, don’t just “explore” the data.

Come prepared with a question you know can be answered.

Read more

I learned three main lessons this year.

1. AI is useful, cool and scary at the same time

I realized that without AI it no longer makes sense to work the old way, especially in tech. Without it, you are much slower. It’s not just about asking a chatbot to write code. It’s about planning architecture, writing clear specs, and setting up your process so AI fits into it easily.

My advice: keep using AI at work and try a lot more “vibe-coding.” It’s fun, and it helps you better understand the technologies that shape our world.

2. Don’t be afraid to try new things

You never know what you will find there.

I hadn’t played football for years. I started again, went out more, met many great people, got into better shape, and began enjoying life much more.

I also returned to poker this year. I earned around $5,000, met some great people who work in investing, and we may even work together on projects. And again, I enjoy my life more.

I started writing too, even though I’m shy and I worry about what people think about me and my ideas. Now many people read me: 37k LinkedIn followers and 3k newsletter subscribers — and I enjoy my life more.

The main point is simple: when you try something new, life becomes more interesting.

Don’t be afraid to start.

3. Consistency is a king.

If you are very talented but not consistent, you won’t be successful. But if you’re fairly average and consistent, you can achieve a lot, but don’t expect results tomorrow or next week — they will come with time.

Remember, 95% of people lack it. If you stay consistent in 2026, you’re already ahead of almost all of them.

I wish all of you to try something new, enjoy your life, and let data help you in it. Thank you all for supporting me and a lot more interesting and useful content happening in 2026!

One of the biggest mindset shifts that helped me (and many people I’ve worked with) is this:

Getting a data scientist job is not a judgment of you as a person.
It’s a game.

And like any serious game, it has rules, strategies, losses, and progression systems. Once you start seeing it this way, everything becomes clearer - and a lot less emotionally draining.

Let’s break it down.

1. It’s a Game. Learn the rules and the optimal strategy

Every game has mechanics. Interviews are no different.

• There are levels (screening, technical, case study, behavioral).

• There are win conditions (clear communication, correct assumptions, trade-offs).

• There are constraints (time, ambiguity, incomplete information).

• There is a meta (what companies currently value, what interviewers expect).

Many candidates fail not because they’re “bad at data science,” but because they don’t know the rules of the game they’re playing.

You wouldn’t start a chess tournament without knowing how pieces move.
Yet many people walk into interviews without understanding:

• What kind of signals interviewers are looking for

• How answers are evaluated

• What “good enough” actually means

Treat preparation as strategy design, not brute-force grinding.

2. You will lose, a lot, and that’s normal

In hard games, losing is part of progression.

You’ll fail interviews.
You’ll get rejected after “great conversations.”
You’ll be ghosted.
You’ll feel like you did everything right and still lost.

That doesn’t mean you’re bad.
It means you’re playing a high-difficulty game.

The key question after every loss is not:

“What’s wrong with me?”

But:

“What did this run teach me?”

• Did I freeze under pressure?

• Did I struggle explaining my thinking?

• Was my SQL not optimal?

• Did I misunderstand the business context?

If you extract one concrete improvement from each loss, you are leveling up, even if it doesn’t feel like it.

3. Interviewers Are Not Final Bosses (They’re NPCs With a Job)

It’s easy to see interviewers as enemies standing between you and the offer.

They’re not.

They’re usually:

• Tired

• Busy

• Slightly stressed

• Trying to assess you fairly with limited time

Most interviewers want you to do well. Your success makes their job easier.

They are not there to destroy you, they’re there to understand:

• How you think

• How you communicate

• How you approach uncertainty

When you remember this, nerves don’t disappear, but they become manageable.

You’re not being attacked.
You’re being observed.

4. Show how you think, not just the final answer

Many candidates treat interviews like speedruns:

“Solve the task. Give the correct answer. Done.”

That’s a mistake.

In real data science:

• Problems are ill-defined

• Goals change

• There is rarely one correct answer

Interviewers care deeply about:

• What assumptions you make

• Why you choose one approach over another

• What trade-offs you consider

• How you react when information is missing

Sometimes there is no “right” answer, only a well-reasoned one.

Think out loud.
Let them see your decision-making process.

That’s often the real quest.

5. Know your strengths and weaknesses before the “Raid”

Before you charge into interviews, you need self-awareness.

Ask yourself:

• Am I strong in SQL but weak in statistics?

• Am I good technically but struggle with business framing?

• Do I panic under time pressure?

• Do I over-focus on perfect solutions?

One of the biggest mistakes I see:

Grinding LeetCode endlessly because it feels productive

Solving 100 problems in a week won’t help if:

• Your real weakness is communication

• Or framing ambiguous questions

• Or explaining trade-offs

Preparation should be targeted, not random.

Good players don’t just grind, they train intentionally.

6. Don’t Play on “Hard Mode” When You Don’t Have To

Not all interviews are equally difficult.
Not all companies expect the same depth.
Not all roles test the same skills.

Yet many candidates:

Read more

1. Statistical Significance: What It Really Means

A lot of folks think “not statistically significant” means “no effect.” That’s not true! If your confidence interval includes zero, it just means you can’t be sure there’s an effect. But you also can’t be sure there isn’t one: there could be a big effect hiding in there.

• Why this matters: If your confidence intervals are wide, you might be missing large effects simply because your data isn’t precise enough.

• What to do: Don’t just look for whether zero is in the interval. Consider the range of possible effects. If you want to be sure you’re not causing harm, check that the lower bound of your confidence interval is above any value you’d consider risky.

2. Small Experiments = Big Problems

Running an experiment with too few participants is like trying to predict the weather by looking out the window for five minutes. Small sample sizes lead to noisy results and wide confidence intervals, making it hard to detect real changes.

• Why this matters: You could miss something big, or get fooled by random noise.

• What to do: Estimate the size of the effect you care about and calculate how many participants you need to reliably detect it (this is called a “power calculation”). Don’t rely on default sample sizes, tailor your experiment to your specific needs.

3. Health Check Failures: Red Flags

Health checks are designed to catch problems in your experiment setup, like unbalanced groups or unexpected data issues. If a health check fails, it’s a warning sign.

• Why this matters: Ignoring these warnings can mess up your results.

• What to do: Investigate and fix the underlying issue before drawing conclusions. Only in rare, well-understood cases should you proceed despite a failed health check.

4. Don’t Dismiss Results Because of Pre-Experiment Differences

Sometimes, the groups in your experiment differ even before the experiment starts. This can happen by chance, especially with random assignment.

• Why this matters: It’s tempting to ignore results if you see these differences, but that’s not necessary. Statistical methods can adjust for these imbalances.

• What to do: Use methods that account for pre-experiment differences, and remember that confidence intervals already factor in the possibility of random imbalances.

5. Beware of P-Hacking

P-hacking happens when you keep searching through different metrics, time periods, or subgroups until you find something statistically significant. This practice increases the risk of finding “false positives”, results that look real but are actually just due to chance.

• Why this matters: The more you look, the more likely you are to find something that isn’t actually there.

• What to do: Decide what you’re going to measure before you start, and stick to it. If you do explore, treat those findings as ideas for future experiments, not as proof.

6. A/A Tests and False Positives

An A/A test is when you split your sample into two groups but don’t apply any treatment. Even in these cases, you might see some statistically significant results just by chance.

• Why this matters: This is a normal part of statistical testing and doesn’t mean your system is broken.

• What to do: Expect a small percentage of false positives, especially if you’re looking at many metrics.

7. Filtering on Post-Experiment Variables Can Bias Results

Read more

Whether you’re new or experienced in your role, your 1:1s with your manager can make a big difference in your growth and day-to-day happiness.

Below are practical tips on how to run 1:1s well so you get more value from them.

1. Own Your 1:1: It’s Your Time

• Remember: The 1:1 is for you. Use it to bring up what matters most to you.

• Prepare an agenda: Keep a running doc where you jot down topics as they come up. This could be anything from technical blockers, career questions, to feedback on team processes.

• Prioritize: When too many topics accumulate, choose the ones that matter most. It’s okay to ask to extend the meeting or schedule follow-up time.

2. Go Beyond Status Updates

• Avoid repeating what’s already covered in team meetings. Use this time to dive deeper: data strategy, experiment design, metrics, assumptions.

• Talk about challenges: Bring up where you’re stuck (modeling issues, ambiguous results, debugging) and ask for guidance.

• Share wins and learnings: Celebrate what’s working, and reflect on what didn’t.

3. Track Follow-Ups

• Write down action items: After each 1:1, note down what you and your manager agreed to do. Tag who owns each follow-up.

• Check back: Review these notes before your next 1:1 to keep things moving.

4. Ask for Feedback and Support

• Proactively seek feedback: Don’t wait for review cycles. Ask how you can improve your analyses, presentations, or impact.

• Clarify expectations: If you’re unsure about priorities or what “success” looks like, ask directly.

• Request resources: Need mentorship on causal inference? Want to learn a new tool? Ask for support or connections.

5. Talk About Career Growth

• Discuss your goals: Share your interests—whether it’s leading projects, deepening technical skills, or exploring new domains.

• Ask for opportunities: Let your manager know what kinds of projects or skills you want to develop.

6. Lead with Vulnerability

• Model openness: Be open about the areas you struggle with, your uncertainties, or what feedback you fear.

7. Use Smart Cadence & Format (bonus one)

Read more

1. Intuition and Experience

• What it is: Relying on personal judgment, gut feelings, or past experiences to make a decision. The other name for that is HiPPO (highest-paid person’s opinion)

• When it’s used: Often the default when time is short or data is unavailable.

• Risks: Highly subjective; may be and is influenced by biases or overconfidence. Not suitable for high-impact or complex decisions.

• Consider: Is the potential downside of being wrong significant? If so, go up one step

2. Correlations

• What it is: Noticing that two things tend to happen together (e.g., users who see more notifications also engage more), therefore correlated.

• When it’s used: Early exploration or when data is limited.

• Risks: Associations can be misleading—just because two things move together doesn’t mean one causes the other. Hidden factors may be at play. Here you can find all the weird correlation examples you can find and imagine now, you will make the business decisions based on that!

• Consider: What other explanations could there be for this pattern? Could a third factor be influencing both?

3. Statistical Adjustments

• What it is: Using statistical models to account for differences between groups (e.g., regression, matching, classification).

• When it’s used: When you have data on relevant characteristics and want to estimate the effect of an action.

• Risks: Only as good as the variables included; unmeasured factors can still bias results. A lot of quality checks and diagnostics should be made for this kind of design.

• Consider: Have you included all important variables? What might you be missing? The main question here is how could two users with the same features get different treatment statuses and why?

4. Quasi-experiments

• What it is: Taking advantage of real-world changes that mimic random assignment (sometimes called “natural experiments”). These changes allow you to compare groups that are similar except for the action or change you’re interested in, helping to estimate cause-and-effect relationships.

• Examples of methods:

  • Differences-in-differences.

  • Synthetic control methods.

  • Regression discontinuity

  • Instrumental variables

• When it’s used: When true randomization isn’t possible, but some external process creates comparable groups.

• Risks: These methods depend on specific assumptions (e.g., that nothing else changed at the same time or parallel trends assumption).

• Consider: What must be true for this approach to give a fair answer? Are those conditions likely met?

5. Meta-analysis of quasi-experiments

Read more

But how exactly can we do it?

Let’s remind ourselves of the formula for sample size:

There are only three levers to reduce the sample size:

• Change the variance

• Change the error level

• Change the Minimum Detectable Effect (MDE)

Let’s dive into the methods that actually move the needle.

1. Change the Minimum Detectable Effect (MDE) directly

The smaller the effect you want to detect, the larger the sample you need.

• If you want to catch tiny changes, you’ll wait months.

• If you’re okay only detecting big shifts, you’ll finish much faster.

👉 Example: detecting a 0.1% uplift in conversion might need millions of users. But if your MDE is 1%, you’ll wrap things up 100x sooner.

For startups, you don’t need to detect a 0.001% effect—your growth should be steep, and there are plenty of low-hanging fruits. Speed matters more than ultra-precision.

For mature companies, it’s the opposite: you’re looking for smaller uplifts because exponential growth is no longer possible, and small improvements compound significantly.

Rule of thumb: don’t aim for microscopic wins unless they really matter to the business.

2. Increase Your Error Level

Statisticians hate this one, but it works.

• Most teams default to 95% significance (α = 0.05).

• But what if you’re okay with 90% (α = 0.10)?

👉 Use this when:

• The decision isn’t mission-critical.

• You’re running early explorations.

• You can re-run later for more precision.

Remember, it’s a trade-off: more speed, slightly higher risk of false positives.

Rule of thumb: only use this if there are no better options left.

3. Use Another Metric

Some metrics are naturally noisy (e.g., revenue per user). Others are cleaner (e.g., conversion rate, click-through).

• If you want speed, choose a lower-variance proxy metric that’s still tightly linked to your business goal.

• Example: Instead of testing impact directly on LTV (which is long-term, high variance), test on 7-day retention or ARPU at 14 days.

👉 The trick: pick a leading indicator that balances signal and speed.

This is why companies need a metric hierarchy—a clear understanding of which metrics are leading indicators and which ones are lagging. Without it, you’ll end up measuring what feels intuitive rather than what’s both fast and useful.

4. Decrease Variance

This is where the real magic happens. Lower variance means you need fewer users for the same level of confidence.

Here are the tools in your toolbox:

a) Outlier Removal

Extreme values can balloon variance (especially in revenue data). By trimming the top/bottom 1–5%, you tighten distributions without losing much signal.

But be careful—if you define “outliers” incorrectly, you might accidentally cut out a meaningful customer segment and bias your results.

b) Stratification

Instead of lumping everyone together, break users into groups (e.g., by country, traffic source, or device). This ensures balanced comparisons and reduces noise.

There are two main flavors:

• Pre-stratification: ensuring randomization is balanced across groups before the test starts (e.g., equal split of mobile vs. desktop).

• Post-stratification: reweighting results after the test to correct imbalances that appeared by chance.

👉 Caveat: stratification works best for small sample sizes. As your experiment grows, randomization naturally balances groups, and the benefit of stratification fades toward zero.

c) CUPED (Controlled Pre-Experiment Data)

CUPED is one of those techniques that feels like magic the first time you see it in action. It was introduced by Microsoft researchers, and it works by using pre-experiment data to reduce noise in your experiment.

Here’s the idea:

• For most metrics, user behavior before the experiment strongly predicts behavior during the experiment.

• Example: If a user spent $100 last month, they’re more likely to spend a lot this month too, regardless of which variant they’re in.

• That prior information is not related to the treatment, but it explains part of the variance in outcomes.

CUPED uses this historical data as a covariate adjustment in the analysis. Essentially, it says:

“Let’s control for what we already know about a user so we can focus only on the treatment effect.”

👉 Why it helps: By explaining away the variance that comes from user history, the leftover “unexplained variance” is smaller. That means fewer users are needed to reach significance.

In practice, CUPED can reduce variance by 20–40% depending on the metric and how predictive past behavior is.

d) VWE (Variance-Weighted Estimator)

Read more

But we all know it’s a lot harder than it looks at first glance.

Here are 7 of the most common reasons why your experimentation might not be working properly:

1. Decentralized experiments = chaos

If every team runs tests on their own, you’ll quickly face:

• Conflicting experiments affecting the same users.

• Overlapping metrics and cannibalization of them

• Teams cherry-picking results to look good.

Solutions:

• Centralization.

A single A/B platform, shared methodology, validated test designs, and a knowledge base of past experiments. This ensures transparency, consistency, and less wasted effort.

2. Skipping experiment design

Some people underestimate the importance of experiment design. But without it, you don’t know:

• How long to run your test.

• Whether you’ll detect meaningful effects.

• The actual power of your experiment.

Good design means calculating MDE (minimum detectable effect), sample size, defining the randomization unit, understanding the metrics, and much more. Without this, you risk stopping too early or wasting weeks on inconclusive data.

3. Peeking too early

A classic mistake. You see significance, get excited, and want to stop right away. But stopping a test the moment you “see a win” increases false positives tenfold.

Solutions:

• General rule: don’t stop before the pre-determined duration.

• Only stop early for strong negative signals (e.g. revenue tanks).

• If your experimentation system is mature, use sequential testing methods (like mSPRT) to control error rates.

4. Ignoring multiple testing

Many data scientists forget that multiple testing is not only about having multiple variants, but it’s also about metrics.

We rarely measure just one metric. But if you track 10+ KPIs without corrections, you’ll almost always find false “wins.”

Solutions:

Read more

Is it really just wall-to-wall modeling and number crunching?

Spoiler: not even close.

In reality, about 70% of my day ( and not only mine ) is spent in discussions with cross-functional partners, aligning on priorities, clarifying metrics, and making sure the work we ship actually moves the needle.

When I share my schedule here, I’ll skip most of the “Discuss X” or “Discuss Y” items (trust me, there are many) and focus on the more distinctive, high-impact activities. Think causal inference puzzles, data sleuthing, experiment design… and a little table tennis.

Here’s what my week actually looks like - from Monday morning coffee to Friday afternoon wrap-up.

MONDAY — Strategy + Sizing

8:00 AM — Breakfast + Inbox Scan
Over coffee and avocado toast, review invites draft for the in-person advertiser event. Strategy isn’t just “who to invite” — it’s balancing reach, potential revenue uplift, and relationship-building.

9:00 AM — Invitation Strategy Deep Dive
Segment advertisers by spend potential, engagement, and likelihood to convert post-event. Build a quick simulation to see which maximizes ROI without overfilling the venue.

10:30 AM — Opportunity Sizing
Run vertical-level revenue models for multiple ad categories. Compare projections to historical campaign lift to validate the numbers.

12:00 PM — Lunch with Colleagues
Swap notes on last quarter’s campaign results and — more importantly — where our next offsite will be.

1:00 PM — Data Engineering Huddle
Explain to DE why we need a new metric in the vertical datatable. Clarify definitions to avoid “two teams, two different metrics” syndrome.

3:00 PM — PM Discussion on Uplift Results
Share last quarter’s experiment outcomes. Brainstorm how to fold the uplift data into next quarter’s planning, adjusting spend and targeting based on measured impact.

4:30 PM — Campaign Analysis Across Regions
Evaluate marketing Threads campaigns worldwide. Identify which creative angles work best per market — and which just drain budget.

TUESDAY — Data & Causal Inference Lab

8:00 AM — Coffee + Prep
List open questions for the day: “Why does PSM + regression adjustment disagree with DiD?” tops the list.

9:00 AM — Causal Method Comparison
Run side-by-side results for PSM+RegAdj vs. DiD. Diagnose differences: sample imbalance? Parallel trends violated? Different covariate coverage?

Read more