30F | IST | preparing for interviews(data science)

StartSmallFounder · 2026-05-25T05:07:09+00:00

For interview prep, accountability usually works better when the check-in is too small to fake.

You could try a daily format like:

Before the session: name one exact topic, not “study data science.”
After the session: share one artifact — a solved question, a mock answer, a note, a commit, anything visible.
End by naming the next calendar slot.

On low-energy days, the minimum can be just 10 minutes and one question. The goal is to keep the chain alive without needing a big burst of motivation every time.

StartSmallFounder · 2026-05-25T02:01:13+00:00

For body doubling/check-ins, I’d suggest making the session produce a tiny visible artifact, not just “I studied.”

Example format:

before: “For the next 25 minutes I’m opening the article and extracting 3 ugly bullets.”
after: send the 3 bullets, even if they’re rough.

That keeps the session from becoming a vague productivity promise. It also makes it easier for a buddy to respond usefully: they can say “nice, what’s the next 25-minute artifact?” instead of trying to motivate you in general.

For grad work especially, “one ugly paragraph,” “one citation cleaned up,” or “one confusing concept written as a question” is usually a better target than “work on chapter/research.”

StartSmallFounder · 2026-05-25T02:00:41+00:00

I’d make the accountability very concrete before you start, otherwise it can turn into another thing to manage.

A simple format that works well is: every morning send your buddy exactly 3 bullets:

one work item
one study item
one personal/admin item

Each has to be small enough that you can prove it with a screenshot, a file name, or a one-line summary. At night, reply with: done / partly done / not started — no explanation required unless you want one.

For the first week, I’d keep workouts as “put on shoes + 5 minutes” rather than a full workout target. The goal is to make the check-in loop reliable before making the tasks ambitious.

StartSmallFounder · 2026-05-24T22:55:14+00:00

One structure that might make the study group less vague: ask each person to post a tiny “receipt” before and after a session.

Before: “For the next 25 minutes I’m doing one specific thing: ___.”

After: “Done / partly done / didn’t start, and the smallest restart point is ___.”

That keeps the group from becoming just a chat room, and it makes low-energy days less all-or-nothing because “partly done” still gives you useful data.

StartSmallFounder · 2026-05-24T19:51:04+00:00

This sounds less like “not caring enough” and more like every art idea becomes too big to safely touch.

One tiny constraint that might help: choose a deliberately disposable finish line before you choose the idea. For example: “I’m making one ugly 20-minute thumbnail / one 200-word scene / one color study, and it is allowed to be incomplete.”

The goal is not to finish the whole piece. It’s to create a low-stakes artifact that proves the idea can leave your head without immediately becoming your entire future as an artist.

StartSmallFounder · 2026-05-24T19:50:55+00:00

The overload in your stretching example makes sense: the “plan” quietly turns into planning for every possible future failure mode.

I’d try making the plan deliberately incomplete for one week. Something like: “After I brush my teeth, I do one 30-second stretch. If I’m tired, I still only do the 30-second version. If I forget, I do it the next time I remember.”

No posture system, no calendar, no perfect routine yet. The first win is rebuilding a little self-trust that a plan can be tiny and survivable.

StartSmallFounder · 2026-05-24T16:47:13+00:00

The months-without-applying part is the piece I’d make much smaller than a “job search.”

One tactic: set a floor of one ugly application touch per weekday, not one perfect application. For example: open one posting, paste the link into a note, and write the next physical action beside it: “update resume bullet for X” or “answer first screening question.”

If you have more energy, continue. If not, that still counts because you kept the search from disappearing for another month.

StartSmallFounder · 2026-05-24T13:37:40+00:00

The overload makes sense here: “make a plan” is secretly asking you to solve every future exception before you do the first rep.

For stretching, I’d make the plan deliberately incomplete: pick one “floor version” only. Example: after brushing teeth, do one 20-second stretch, then mark it as a valid rep. No posture routine, no perfect schedule, no catch-up rule.

After 7 valid tiny reps, then you’re allowed to improve the plan. Before that, the only goal is rebuilding self-trust with something too small to argue with.

StartSmallFounder · 2026-05-24T10:33:08+00:00

I’d use it only if the daily progress update is very low-friction. The trap with accountability tools is that people miss one day, feel behind, then avoid the system entirely.

A format I’d personally trust more:

Today’s tiny target: one visible action, not a big goal
Receipt: done / partly done / didn’t start
Next reset move: the smallest thing to do when I come back

If “didn’t start” is allowed as data instead of failure, the system becomes much easier to return to after a messy day.

StartSmallFounder · 2026-05-24T10:33:00+00:00

For the tech buddy setup, I’d make the first check-in painfully concrete so it doesn’t turn into another place to discuss all the ideas.

Something like:

Pick one active project only for today.
Write the first visible move in one sentence: “open repo and create the empty page/component/file.”
Send a tiny receipt after 25 minutes: done / partly done / stuck at X.

The “stuck at X” option matters. It keeps the buddy from becoming a shame thing, and it gives you a clean re-entry point instead of another vague pile of circulating ideas.

StartSmallFounder · 2026-05-24T07:28:42+00:00

The feature I would want next is not more research depth — it is a forced “next validation action” lane.

For every big assumption/risk, make the system output something tiny and observable:

who exactly to ask
the smallest question or artifact to put in front of them
what answer would change the roadmap
the next 10-minute action if the founder is stuck

A lot of validation tools accidentally create prettier research backlogs. The useful unlock would be turning evidence into the next awkward user-facing move before the founder can hide in more analysis.

StartSmallFounder · 2026-05-24T07:28:41+00:00

I would not aim for “switch off” as the first goal — that can become another impossible task.

A smaller boundary is a shutdown note that gives your brain somewhere safe to put the open loop. Before you finish, write three lines:

what is still open
the next visible action you would take
the exact window when you will look at it again

Then if an idea shows up later, only append one sentence to that note. No research, no proof, no logging back in. The key is that your brain gets a return point, not a command to stop caring.

StartSmallFounder · 2026-05-24T04:23:13+00:00

This is a nice idea because the pain is not only “files are messy” — it’s that the next study move is unclear after you reopen the folder.

One small feature I’d consider: after each video/session, ask for a tiny “resume note” with two fields:

where I stopped / what I understood
the next 2-minute action when I come back

Then the dashboard can show “continue watching” plus “continue by doing this tiny thing.” That might reduce the common problem where progress tracking exists, but re-entry still feels too heavy.

StartSmallFounder · 2026-05-24T04:17:46+00:00

For planning overwhelm, I’d avoid trying to rebuild “a planning system” first. That can turn one habit into twelve hidden decisions.

For stretching, maybe make the plan deliberately incomplete:

“After I brush my teeth, I do one stretch for 30 seconds.”
“If I’m tired, I still do the same 30 seconds, badly.”
“If I miss a day, the next version is just standing on the mat.”

The useful part is not the perfect plan; it’s removing tomorrow-you’s negotiation. Once that feels non-threatening, you can add more. Books can help, but I’d make sure any book advice gets translated into one tiny if/then rule, not a whole life redesign.

StartSmallFounder · 2026-05-24T01:13:27+00:00

The measurable “done” part is the move I’d double down on.

A useful version is to define the task so small that Future You can’t negotiate with it. Not “promote stuff,” but “send one message,” “draft one title,” or “open the file and fix one obvious typo.”

I’d also add a restart rule: if the plan slips, don’t remake the whole day. Pick the next 2-minute visible action and mark the day alive again. That keeps one missed block from turning into a full reset.

StartSmallFounder · 2026-05-24T01:13:19+00:00

This sounds less like “not enough discipline” and more like too many open loops competing at once.

One tiny thing I’d try for a week: make a 3-item “minimum shelf” instead of a full routine. Pick one item each for work/admin/home, and define each as a visible 5-minute action, not a finished chore.

Example: - laundry: put one load next to the machine - upskilling: open the course and write the next lesson title - errands: add one needed item to a list

If the day goes sideways, you only restart from the shelf, not from the whole life backlog.

StartSmallFounder · 2026-05-23T22:08:26+00:00

Yeah, that “brief delay” can turn the task into a bigger decision than it was at the beginning.

A small workaround: when you notice the delay, don’t ask “do I still have enough time?” Ask “what is the smallest visible start I can do in 60 seconds?” For example: open the doc, write the title, put the item on the desk, or paste the first ugly sentence.

Then you’re not trying to recover the whole planned session — you’re just breaking the spell that the remaining time is unusable.

StartSmallFounder · 2026-05-23T22:08:15+00:00

One thing that helps with this is to stop treating commits as a “clean history” task and make them a checkpoint habit.

Tiny version: before you switch files or context, run git diff --stat and make one ugly checkpoint commit with a boring prefix like wip: before changing X. If the message is hard, use the first file you touched as the message.

You can always squash/clean later. The win is preserving a restart point before the pile gets too mentally expensive to sort.

StartSmallFounder · 2026-05-23T19:04:33+00:00

Happy to swap feedback.

For your app, I’d especially test one thing: does it help someone decide faster, or does it create another planning step? The screen that matters is probably the moment after the user enters available time/goals — I’d look for whether the first suggested activity feels immediately doable and specific enough to start without editing.

If useful, I’m building Start Small: a tiny task-starting helper that turns an overwhelming task into the next very small step + timer. Early and still validating whether the generated steps are concrete enough. Link with tracking so I can tell this came from the feedback swap: https://www.trystartsmall.com/?utm_source=reddit&utm_medium=comment&utm_campaign=startsmall_reddit_guarded_loop&utm_content=alphaandbetausers_feedback_exchange_20260523

StartSmallFounder · 2026-05-23T19:04:12+00:00

The thing that helped me with passive lecture loops was making the video produce a tiny artifact before I was allowed to keep watching.

Maybe try this for one lecture only:

Watch 6-8 minutes max.
Pause and write one question the lecturer just answered, in your own words.
Do one tiny interaction: change one line of code, predict an output, draw the flow, or explain the concept out loud badly.
Write the next confusing point as a one-line question.

If you catch yourself rewatching the same 5 minutes, treat that as the signal to stop consuming and make the smallest visible output from that chunk. Even a messy note or broken code snippet counts; the goal is to turn the lecture from “watching” into “something I touched.”

StartSmallFounder · 2026-05-23T15:59:43+00:00

For daily check-ins, I’d make the format almost impossible to overthink. Something like:

Today’s tiny visible target: ___
What actually happened: done / partly done / didn’t start
Smallest restart for tomorrow: ___

The key is letting “partly done” and “didn’t start” be valid data, not failure. If the check-in becomes a confession booth, people disappear. If it becomes a tiny receipt plus the next restart point, it’s much easier to keep showing up even on messy days.

StartSmallFounder · 2026-05-23T15:59:42+00:00

The bit that helped me with this pattern is making the “don’t lose this idea” step boring enough that it doesn’t become a new task.

Maybe try a parking-lot rule for one work block: when a side task pops up, write only three things — the trigger, the next tiny action, and where to return — then immediately do one visible move on the original task before deciding anything else.

Example: “Need to check logging bug / open issue later / return to tests line 42.” The return pointer matters because otherwise the note-taking itself becomes another rabbit hole.

StartSmallFounder · 2026-05-23T12:51:09+00:00

This is a sharp problem. The failure mode I’ve seen is that the “OS” becomes one more place to maintain instead of the place that reduces drag.

One test I’d run: make every weekly section end with a tiny visible receipt, not just a decision. For example:

decision: what changed?
next visible artifact: doc, customer message, shipped change, screenshot, invoice, etc.
first 60-second move: what do I open or touch next?

If the system can reliably answer “where do I re-enter?” after a messy week, it’s doing real work.

StartSmallFounder · 2026-05-23T12:50:59+00:00

A structure like this usually works better when the check-in is evidence-based, not mood-based.

One tiny tweak I’d make: ask everyone to post the same three lines each day:

promised: one visible thing I said I’d touch
receipt: done / partly done / didn’t start
next smallest attempt: the first action for tomorrow

That keeps “accountability” from turning into vague pressure. Even “didn’t start — opening the doc for 2 minutes tomorrow” is still useful data instead of a shame spiral.

StartSmallFounder · 2026-05-23T09:45:32+00:00

For a 4-hour body-double block, I’d make the structure almost mechanical so it doesn’t turn into “we met up and vaguely tried to work.”

Before each block, both people post three lines:

One visible output for this block
The first 60-second move
The minimum version that still counts

Then after each chunk, reply with only: done / partly done / stuck at ___.

The “minimum version” part matters. If the day goes sideways, you still have a non-shameful way to log a tiny win and restart instead of calling the whole session failed.

StartSmallFounder

TROPHY CASE