# Blog

> Practical guides for software engineers: answering questions about code in meetings, preparing for interviews, and what happens to your code and audio when an AI assistant is listening.

Source: https://hintvo.com/blog | Reviewed: 2026-11-20

Practical guides for software engineers: answering questions about code in meetings, preparing for interviews, technical terms in plain words, and what happens to your code and audio when an AI assistant is listening.

## Technical meetings

Planning, reviews, incidents and the first weeks on a new codebase.

- [How to answer questions about code you did not write](https://hintvo.com/blog/answer-questions-about-code-you-did-not-write.md): A meeting question lands on code someone else wrote. How to answer honestly in the moment: find the entry point, say what you can stand behind, name what you still have to check.
- [Sprint planning: estimate from what the change touches](https://hintvo.com/blog/sprint-planning-estimates-from-the-code.md): Estimates go wrong when nobody looked at the code. A five-minute routine for sizing a change by what it touches: entry points, data, callers, tests and edges.
- [Incident calls: find the code path while people are talking](https://hintvo.com/blog/incident-call-find-the-code-path-fast.md): Five people searching the same repository is slow. Roles, a search order and the sentences that move an incident call from the search to the fix.
- [Design reviews: ten questions worth asking](https://hintvo.com/blog/design-review-questions-worth-asking.md): The useful question in a design review is the one the author has stopped seeing. Ten questions about failure, data, operations and change, and how to ask them without stalling the review.
- [Your first weeks on a new codebase: follow the meetings before you know the code](https://hintvo.com/blog/first-weeks-on-a-new-codebase.md): In your first weeks the meetings move faster than your reading. Learn the words, learn where things enter the system, and ask questions that show you looked.
- [Meeting notes developers actually use](https://hintvo.com/blog/meeting-notes-developers-actually-use.md): Most meeting notes are a transcript nobody reads. Notes that get used answer four questions: what we decided, what is open, who does what by when, and which files it touches.
- [How to explain a technical term in plain words](https://hintvo.com/blog/explain-technical-terms-in-plain-words.md): A plain explanation is one sentence that says what the thing is for, then what it means for the listener. A pattern, six worked examples and three habits to drop.
- [You lost the thread in a meeting. How to catch up without derailing it](https://hintvo.com/blog/lost-the-thread-in-a-meeting.md): Everyone drifts in long calls. The cost is not the minute you missed but the ten you spend pretending. How to find the current question and ask one precise thing.
- [How to prepare for a technical meeting in five minutes](https://hintvo.com/blog/prepare-for-a-technical-meeting-in-five-minutes.md): Five minutes is enough if you spend them on three things: what will be decided, which code it is about, and the one question you want answered.
- [Answer a customer's technical question on the call](https://hintvo.com/blog/customer-calls-technical-questions.md): Many customer questions have an exact answer sitting in the code: a limit, an error, a default. How to find it, check it and say it during the call, and when to follow up instead.
- [Stand-ups that actually take ten minutes](https://hintvo.com/blog/stand-ups-that-take-ten-minutes.md): A stand-up exists to find what is blocked and who needs to talk to whom. How to run it by the work instead of by the person, and where the long discussions should go.
- [How to say "I don't know" in a technical meeting](https://hintvo.com/blog/how-to-say-i-do-not-know-in-a-technical-meeting.md): Bluffing costs more than not knowing. Three ways to say you do not know that leave people trusting you more, and the follow-through that makes them work.
- [How to walk a team through your pull request](https://hintvo.com/blog/walk-a-team-through-your-pull-request.md): A code walkthrough is ten minutes, in this order: the problem, the change in reading order, what you are unsure about, how it was tested, and how to undo it.
- [Retrospectives that change something](https://hintvo.com/blog/retrospectives-that-change-something.md): Most retrospectives produce a list and no change. Check the last action first, collect facts before opinions, and leave with one change that has an owner and a date.
- [Write the decision down: a one-page decision record](https://hintvo.com/blog/write-the-decision-down.md): Teams repeat arguments because nobody wrote down why. A decision record is one page: the context, the decision, what you rejected and what it costs. A template you can copy.
- [Taking over a service: what to ask in the handover meeting](https://hintvo.com/blog/taking-over-a-service-handover-questions.md): You have one hour with the person who knows the service. The questions that matter: what it does, where it runs, how it breaks, how you find out, and what they never fixed.
- [Meeting another team about their API: what to ask before you build on it](https://hintvo.com/blog/meeting-another-team-about-their-api.md): One meeting before you build on another team's API can save weeks. The questions about limits, errors, changes, events and ownership that are cheaper to ask now than to discover later.
- [Blameless postmortem meetings: an agenda and a template](https://hintvo.com/blog/blameless-postmortem-meeting.md): A postmortem is useful when it ends with changes, not blame. A 45-minute agenda, a written template you can copy, and the questions that find causes instead of culprits.
- [1:1s with your manager: an agenda for software engineers](https://hintvo.com/blog/one-on-one-with-your-manager-as-an-engineer.md): A one-on-one is the one meeting that belongs to you. What to bring, a running agenda you can copy, the questions worth asking every few months, and how to raise a problem early.
- [How to explain technical work to non-technical stakeholders](https://hintvo.com/blog/explain-technical-work-to-non-technical-stakeholders.md): Stakeholders do not need the architecture. They need what changes for them, what it costs and what could go wrong. A structure for updates, estimates and bad news, with examples.
- [Backlog refinement that works: get tickets ready in half the time](https://hintvo.com/blog/backlog-refinement-meeting.md): Refinement is where vague tickets become work someone can start. A definition of ready, a ten-minute routine per ticket, ways to split big tickets, and how to stop the meeting turning into design.
- [Technical project kickoff: what to settle in the first meeting](https://hintvo.com/blog/technical-project-kickoff-meeting.md): A kickoff decides most of what goes wrong later. The goal, what is out of scope, who decides and the riskiest assumption to test first. An agenda and a one-page brief to copy.
- [The follow-up email after a technical meeting: a template](https://hintvo.com/blog/follow-up-email-after-a-technical-meeting.md): A five-line follow-up turns a meeting into commitments. When to send it, what goes in, a template you can copy, and what to do when someone remembers a decision differently.
- [Speaking up in meetings when you are the quiet engineer](https://hintvo.com/blog/speak-up-in-meetings-as-an-engineer.md): Quiet engineers often have the best point in the room and no way in. Prepare one contribution, speak in the first ten minutes, and turn a doubt into a question people can answer.
- [Should this be a meeting? When a written update works better](https://hintvo.com/blog/should-this-be-a-meeting.md): Many meetings are status updates that would be faster to read. A simple test for when to meet and when to write, a format for written updates, and how to make the meetings you keep shorter.
- [Meeting templates for software engineers: 8 you can copy](https://hintvo.com/blog/meeting-templates-for-software-engineers.md): Eight plain-text templates for technical teams: meeting prep, kickoff brief, notes, follow-up email, decision record, status update, 1:1 agenda and blameless postmortem.

## Interviews

Behavioral, coding and system design rounds, for candidates and for interviewers.

- [Behavioral interview questions: build your answers from your own CV](https://hintvo.com/blog/behavioral-interview-answers-from-your-cv.md): Behavioral questions are predictable. Turn your CV into six stories before the interview, tell each one in four parts, and keep it under two minutes.
- ["Tell me about yourself" for software engineers: a 90-second answer](https://hintvo.com/blog/tell-me-about-yourself-for-software-engineers.md): The first question of most interviews, and the one people prepare least. A three-part structure: what you do now, how you got there, why this job.
- [Coding interviews: what to do in the first five minutes](https://hintvo.com/blog/coding-interview-first-five-minutes.md): Most coding interviews are decided before the first line of code. Restate the problem, ask about the inputs, work one example by hand, and say the simple solution first.
- [System design interviews: a structure that holds when you are nervous](https://hintvo.com/blog/system-design-interview-structure.md): A system design interview has no right answer, but it has a right order. Six steps and how to split forty-five minutes between them.
- ["Do you have any questions for us?" Questions worth asking](https://hintvo.com/blog/questions-to-ask-your-interviewer.md): The last five minutes of an interview are yours. Fourteen questions about the work, the team, on-call and growth, and how to choose the two or three that fit.
- [The night before an interview: a one-hour practice plan](https://hintvo.com/blog/practice-interview-the-night-before.md): The night before is for rehearsing what you already know, not learning new things. One hour, four blocks: the job post, five questions out loud, one coding problem, and the logistics.
- [Is AI allowed in your interview? How to find out, and what to do either way](https://hintvo.com/blog/is-ai-allowed-in-your-interview.md): Rules on AI tools differ by company and even by round. How to ask the recruiter in two sentences, how to read the answer, and how to prepare when the answer is no.
- [Interviewing in your second language](https://hintvo.com/blog/interviewing-in-a-second-language.md): You are being hired for your engineering, not your accent. How to buy time, ask for a repeat without apology, and practice so the words are there when you need them.
- [For interviewers: how to run a fair technical interview](https://hintvo.com/blog/run-a-fair-technical-interview.md): A fair interview is planned before the candidate arrives. Decide what you are looking for, ask everyone the same core questions, write down what was said, and score each part on its own.
- [Three interview questions everyone hates, and how to answer them](https://hintvo.com/blog/three-interview-questions-everyone-hates.md): Your greatest weakness, a time you failed, and why you are leaving. What each question is really asking, and an honest way to answer it.
- [Debugging interviews: finding a bug in code you have never seen](https://hintvo.com/blog/debugging-interview-find-the-bug.md): In a debugging round you are given unfamiliar code with something wrong in it. A method that works under pressure: read first, state what should happen, narrow it down, and check the units.
- [Pair programming interviews: how to think out loud](https://hintvo.com/blog/pair-programming-interview-think-out-loud.md): A pairing round grades how you work with another person, not only whether the code runs. Say your intent before you type, treat the interviewer as a teammate, and take hints well.
- [How to explain a past project in an interview](https://hintvo.com/blog/explain-a-past-project-in-an-interview.md): "Walk me through a project you worked on" tests whether you can explain a system to someone who was not there. A two-minute structure in six parts, and what to prepare.
- [Take-home assignments: how to present your solution in the review call](https://hintvo.com/blog/take-home-assignment-review-call.md): The review call decides more than the code does. Send a README that answers the first questions, give a five-minute tour, name the weak spots yourself, and be ready to change it live.
- [How to answer "what are your salary expectations?"](https://hintvo.com/blog/salary-expectations-question.md): The question comes early and feels like a trap. Do your research first, know your own number, and choose between three honest answers depending on the stage.
- [After the interview: what to write down and what to send](https://hintvo.com/blog/after-the-interview-follow-up.md): The half hour after an interview is worth more than another hour of preparation. What to write down while you remember it, the four-sentence thank-you note, and what to do with a rejection.
- [How to answer "Why do you want to work here?"](https://hintvo.com/blog/why-do-you-want-to-work-here.md): The question checks whether you chose this company or just any company. A real answer has three parts: something specific about them, something true about you, and the link between the two.
- [How to answer "Why should we hire you?"](https://hintvo.com/blog/why-should-we-hire-you.md): It sounds like an invitation to boast. It is a request for a summary: what they need, the evidence that you have done it, and one thing you bring that the job post did not ask for.
- [How to answer "Where do you see yourself in five years?"](https://hintvo.com/blog/where-do-you-see-yourself-in-five-years.md): Nobody expects a five-year plan. The question asks whether this job fits the direction you are going. Name a direction, tie it to the role, and be honest about what you do not know.
- ["Tell me about the hardest bug you fixed": how to tell a debugging story](https://hintvo.com/blog/hardest-bug-you-have-fixed.md): A debugging story shows how you think when you do not know the answer. Tell it in five beats: the symptom, what you ruled out, the turning point, the cause, and what you changed afterwards.
- [When the interviewer asks about a technology you have not used](https://hintvo.com/blog/interview-question-about-technology-you-have-not-used.md): You will be asked about a tool you have never touched. Say so in one sentence, name the closest thing you have used, map the concepts across, and show how you learn.
- [How to explain a gap or a short job on your CV](https://hintvo.com/blog/explain-a-gap-in-your-cv.md): Gaps, layoffs and jobs that lasted six months are common, and interviewers have seen all of them. One honest sentence, one sentence on what you did, and back to the work.
- [Senior and staff engineer interviews: what changes](https://hintvo.com/blog/senior-engineer-interview-what-changes.md): At senior level the questions sound the same and are graded differently. Scope, judgment and influence replace speed. What interviewers look for, and how to show it in each round.
- [Your first engineering job interview: what a junior candidate is graded on](https://hintvo.com/blog/first-engineering-job-interview.md): Nobody expects a junior engineer to know everything. Interviewers look for fundamentals, how you learn and how you take feedback. What to prepare when you have little work experience.
- [SQL interview questions: an approach that works for any query](https://hintvo.com/blog/sql-interview-approach.md): Most SQL interview questions are the same five ideas in different clothes. Read the tables first, build the query in the order the database runs it, and check the three classic traps.
- [Remote interview setup: a ten-minute checklist](https://hintvo.com/blog/remote-interview-setup-checklist.md): Most remote interview problems are technical and avoidable: the wrong microphone, a notification on a shared screen, a laptop at four percent. A checklist for the hour before.
- [The recruiter phone screen: what it decides and how to pass it](https://hintvo.com/blog/recruiter-phone-screen.md): The first call is short and decides whether the process continues. What the recruiter needs to hear, the questions to expect, and what you should ask before investing more time.
- [Engineering manager interviews: the four things they test](https://hintvo.com/blog/engineering-manager-interview.md): A manager interview tests people, delivery, technical judgment and how you work with your own peers. What each round looks for, and the eight stories to prepare before you go in.
- [200 software engineer interview questions by role, and what good answers show](https://hintvo.com/blog/software-engineer-interview-questions-by-role.md): 200 interview questions for software engineers: 20 that every role gets, then 30 each for backend, frontend, DevOps and SRE, data, mobile and machine learning roles.
- [30 backend developer interview questions, and what a good answer shows](https://hintvo.com/blog/backend-developer-interview-questions.md): Thirty backend developer interview questions on APIs, databases, reliability, security and production debugging, each with a short note on what a strong answer covers.
- [30 frontend developer interview questions, and what a good answer shows](https://hintvo.com/blog/frontend-developer-interview-questions.md): Thirty frontend developer interview questions on the browser, JavaScript and TypeScript, components, performance and accessibility, each with what a strong answer covers.
- [30 DevOps and SRE interview questions, and what a good answer shows](https://hintvo.com/blog/devops-sre-interview-questions.md): Thirty DevOps and site reliability engineer interview questions on Linux, networking, containers, CI/CD, observability and incidents, each with what a strong answer covers.
- [30 data engineer interview questions, and what a good answer shows](https://hintvo.com/blog/data-engineer-interview-questions.md): Thirty data engineer interview questions on SQL, data modeling, pipelines, data quality, storage and distributed processing, each with what a strong answer covers.
- [30 mobile developer interview questions, and what a good answer shows](https://hintvo.com/blog/mobile-developer-interview-questions.md): Thirty mobile developer interview questions for iOS and Android roles on the app lifecycle, architecture, networking, performance and releases, each with what a strong answer covers.
- [30 machine learning engineer interview questions, and what a good answer shows](https://hintvo.com/blog/machine-learning-engineer-interview-questions.md): Thirty machine learning engineer interview questions on fundamentals, features, models in production and LLM applications, each with what a strong answer covers.

## In plain words

Terms you will hear in meetings and interviews: one sentence first, then how it works and where it goes wrong.

- [Idempotency in plain words: why a retry must not charge twice](https://hintvo.com/blog/idempotency-in-plain-words.md): An operation is idempotent when doing it twice has the same effect as doing it once. What that means for payments and retries, and how an idempotency key works.
- [Retries and backoff in plain words](https://hintvo.com/blog/retries-and-backoff-in-plain-words.md): A retry is trying a failed operation again. Backoff is waiting longer before each new try. When retrying helps, when it makes an outage worse, and the four settings every retry needs.
- [Rate limiting in plain words](https://hintvo.com/blog/rate-limiting-in-plain-words.md): A rate limit caps how many requests one client can make in a period, so one heavy user cannot slow down everyone else. How a token bucket works, and what a client should do when limited.
- [Caching in plain words: fast answers and stale ones](https://hintvo.com/blog/caching-in-plain-words.md): A cache keeps a copy of an answer that was expensive to work out, so the next request is fast. The price is that the copy can be out of date. How to decide what to cache and for how long.
- [Database migrations in plain words](https://hintvo.com/blog/database-migrations-in-plain-words.md): A migration is a scripted change to the shape of a database, run once and kept with the code. Why existing rows and the order of deploys matter, and how to change a column safely.
- [Feature flags in plain words](https://hintvo.com/blog/feature-flags-in-plain-words.md): A feature flag is a switch that turns a feature on or off without a new release. What flags make possible, the four kinds you will meet, and why old flags have to be removed.
- [Race conditions in plain words](https://hintvo.com/blog/race-conditions-in-plain-words.md): A race condition is a bug that appears only when two things happen at almost the same moment, in an order the code did not expect. A worked example and four ways to prevent it.
- [Message queues in plain words](https://hintvo.com/blog/message-queues-in-plain-words.md): A queue lets one part of a system hand work to another without waiting for it. What that buys you, what it costs, and the words that come with it: worker, acknowledge, dead letter.
- [Webhooks in plain words](https://hintvo.com/blog/webhooks-in-plain-words.md): A webhook is one system calling another when something happens, instead of being asked over and over. How to receive one safely: verify it, answer fast, and expect duplicates.
- [Database indexes in plain words](https://hintvo.com/blog/database-indexes-in-plain-words.md): An index is a sorted lookup that lets a database find rows without reading the whole table. What it speeds up, what it costs, and how to tell whether a slow query needs one.
- [The N+1 query problem in plain words](https://hintvo.com/blog/n-plus-one-queries-in-plain-words.md): One query fetches a list, then one more query runs for every item in it. Why it hides so well in development, how to spot it in the logs, and the two standard fixes.
- [Database transactions in plain words](https://hintvo.com/blog/database-transactions-in-plain-words.md): A transaction groups several changes so that either all of them happen or none do. What that protects, what it does not, and the mistakes that make transactions slow or useless.

## Privacy and trust

What an assistant hears, where your code goes and how to check an answer.

- [Meeting bots vs listening on your computer: who sees what](https://hintvo.com/blog/meeting-bots-vs-listening-on-your-computer.md): An AI assistant can hear a call in two ways: by joining it as a participant, or by listening on your own computer. What each one means for the other people, for your data and for your duties.
- [What leaves your computer when an AI answers a question about your code](https://hintvo.com/blog/what-leaves-your-computer-when-ai-reads-your-code.md): Before you point any AI tool at a repository, ask five questions about where the code goes. The questions, and Hintvo's own answers to each.
- [Why an AI answer about your code should name its file and line](https://hintvo.com/blog/why-ai-answers-need-file-and-line.md): A language model can describe code that usually looks like yours. An answer you can use in a meeting has to come from what is actually in the repository, and show where.
- [How to tell people a call is being transcribed](https://hintvo.com/blog/how-to-tell-people-a-call-is-transcribed.md): If a tool is turning a call into text, the other people may have a right to know. When to say it, three ways to say it in one sentence, and what to do when someone objects.
- [How to ask your company whether you can use an AI assistant at work](https://hintvo.com/blog/ask-your-company-about-ai-assistants.md): Most companies have a rule about AI tools, written or not. Who to ask, the five things they will want to know, and a message you can adapt, with Hintvo's answers filled in.

## Using Hintvo

Pricing, the free trial and how the app works with your project.

- [Per minute, per session or per month: what AI meeting help really costs](https://hintvo.com/blog/per-minute-per-session-or-subscription.md): AI assistants charge in three ways: a monthly subscription, a price per session or credit, or the minutes you actually use. How to work out which is cheapest for the way you work.
- [Three free sessions: how to test Hintvo properly](https://hintvo.com/blog/three-free-sessions-how-to-test-hintvo.md): The free trial is 3 sessions of up to 10 minutes. A plan for each one, so you find out whether it helps in your meetings and interviews before you pay anything.
- [Hidden from screen sharing: what it does and when to turn it off](https://hintvo.com/blog/hidden-from-screen-sharing-explained.md): Hintvo's windows are left out of what you share by default. What that protects, what it does not change, and the two cases where you should switch it off.
- [Which code Hintvo can read: languages, editors and what it skips](https://hintvo.com/blog/which-code-hintvo-can-read.md): What happens when you add a project folder: which languages get a map of functions and classes, what is skipped, the two ways a project can be learned, and which editors open a cited line.

## Related

- [AI meeting assistant for developers, with answers from your code](https://hintvo.com/meeting-assistant-for-developers.md): How does Hintvo AI help in sprint planning, design reviews and incident calls?
- [AI interview copilot that answers from your CV](https://hintvo.com/interview-copilot.md): How does Hintvo AI help in a job interview, and how do I practice with it?
- [Get started with Hintvo AI](https://hintvo.com/get-started.md): What do I need, how do I set it up, and what does the free trial include?
