VISend JD

Tech Lead · how I work

What I actually spend my days on, and why I do it this way.

Every
pull request reviewed before merge
10–20
people on the team
6+
years building web and mobile products
2
hats at once: Product Owner and Tech Lead

01

Code review

I read every pull request before it merges. Not to play gatekeeper. Review is the cheapest place to catch a bug, and the best place to teach.

  1. I ask, I don't rule

    Instead of "this is wrong", I ask the question that makes the author walk the flow again: "When you change the time, does this still run? So the old job is still there? Two notifications, then?" Most people find the bug before they finish replying.

  2. Real numbers, not "might be slow"

    "This could hurt performance" helps nobody. I ask what happens at the biggest size we actually have. An await inside a loop is fine with ten rows. Is it fine with our largest import?

  3. Three colours

    Red means it can't merge: a bug, a leak, a missed spec. Yellow means please fix. White means I'm just asking. The colour follows what happens to the user, not how sure I am about the fix.

  4. What I let go

    A forgotten log line, a so-so name, formatting. Block PRs over nits and people stop opening small PRs. Small PRs are exactly what I want.

02

Tech debt

Every team has a debt list nobody wants to open. My job is to turn it into something we actually finish, without stopping feature work.

  1. Group it the way QA tests

    Grouping by code module looks tidy, but QA tests by user flow. So I group debts by flow. Testing one group means walking one journey end to end.

  2. Nothing untested reaches the main branch

    Fixes land in a phase branch first. The whole phase goes to the main branch in one PR, after QA signs off. I track a few phases instead of dozens of loose PRs.

  3. First to claim it owns it

    Put several people on one list and two of them will fix the same bug eventually. So each debt page doubles as the sign-up sheet.

  4. A bugfix is not a product decision

    If a fix changes what users see, it waits for a product call. Nobody should have to make that call quietly inside a bugfix.

03

Performance

When something is slow, I'd rather read the query plan than argue about it.

  1. Plans before opinions

    For a slow area I pull the queries, read their plans and write down what I find. Then we talk.

  2. Look, don't touch

    Investigating never changes data. If a query is known to be heavy, I note it instead of running it on a busy database.

  3. Findings become tickets

    A missing index or a repeated round trip goes onto the debt list with a priority. Otherwise it dies in a slide deck.

04

Data migrations

Moving data to a new shape while the product keeps running. The new shape is rarely the hard part. The months in between are.

  1. Count before you cut

    Before touching code I count who reads the old data, and how. Often most of them go through one layer. Keep that layer's shape and they never notice the move.

  2. One home for the fallback

    "Read the new thing, fall back to the old one" lives in exactly one module. Scatter it around and nobody will ever dare delete the old field.

  3. A backfill you can run twice

    Split the work into ranges, one job per range. A failed range retries on its own, and running everything again gives the same result. Nobody has to stay up watching it.

  4. No big bang

    Old fields stay as a safety net until production data checks out. Deleting them is the very last step, done once.

05

Wearing both hats

As Product Owner I decide what gets built. As Tech Lead I answer for how. Handy: most arguments happen in my own head first.

  1. PRDs in plain language

    No function names in a PRD. If the business side can't read it, it's a tech spec in a PRD costume.

  2. Open the code before writing a story

    If the screen or the API already exists, we don't need a new story. One line saying we reuse it is enough.

  3. Decide, then delete the question

    Once an open question is answered, the answer goes into a business rule and the question goes away. Otherwise every page grows a long table nobody trusts.

  4. Plans that follow the release

    Kanban while we figure things out, Scrum once the work is ready. New work is sized against work we've already finished, not against a gut feeling.

  5. The people part

    Weekly progress updates, monthly performance reviews, and onboarding docs so new people don't have to ask the same ten questions.

06

AI in my workflow

If I leave the same review comment every week, a machine can leave it first.

  1. A reviewer that sounds like me

    I wrote down what I look for and, harder, what I don't comment on. The agent reads the diff and the ticket and leaves short comments in my style.

  2. Small permissions

    It can comment and approve. It can't merge. If it isn't sure and can't check quickly, it stays quiet.

  3. It reviews me too

    My own PRs go through the same rules. The only difference: the findings come to me instead of going public.

  4. What stays human

    Product calls, anything users will notice, and the merge button.

Contact

Looking for a Tech Lead?

I want to own the technical direction and help a team ship products that matter.

huybn.dev97@gmail.com