Help & FAQ

A live technical-interview room: a shared code editor with live cursors, code execution in 8 languages, a shared whiteboard, and interviewer-only notes. Interviewers can also send timed take-home assessments and replay any session afterwards.

Hire Pad is in early access and accounts are by invitation: request early access, or ask your team's Hire Pad admin to add you. Then sign in at /login with your email and password.

No. Open the link your interviewer sent, type the name you'd like to be shown, and select Join Interview. Take-homes work the same way.

Your role comes from your signed-in session, never from anything typed into the page. Sign in first (/login), then open the room link in the same browser. You're recognized as the interviewer only in rooms you created.

On the dashboard, select New Interview, give it a title and language (candidate name, email, and a date are optional), then Generate Interview Link. Copy the link and send it to the candidate. You can copy it again later from Interviews (the copy icon on each row).

Dashboard gives an overview: counts of upcoming, live, and completed interviews, total code runs, live and upcoming interviews (an interview goes live when the candidate joins), recently completed ones, and the languages you use. The sidebar shows which account is signed in. Interviews lists every live interview with search, copy-link, replay, and join actions.

Select Finish in the room header and confirm. Only the interviewer sees this button. Both participants then see that the interview has ended, the candidate is disconnected and can't rejoin, no more code can be run, and the interview is marked completed on your dashboard. You can still reopen the room (signed in) to look over the final code. If you forget, an interview with no activity for 7 days is finished automatically.

In a live interview the bar under the room header has two switches, Code execution and Block copy and paste, and you can change either at any time. With code execution off, the candidate's Run is disabled and the server refuses their runs (you can still run); turn it back on and they can run again straight away. Blocking paste stops the candidate pasting into the editor and copying the question; typing works as normal. Pasting is a deterrent in the browser, not a guarantee, so don't rely on it alone. The candidate is told when either is on, both sides see the state, and each change appears in the replay. Take-homes always let the candidate run code.

Select the trash icon on its row in Interviews or Take-homes, and confirm. This permanently deletes it, along with its replay, notes, and code runs; it can't be undone. Anyone still in the room is disconnected within about 30 seconds, and the link stops working.

Use the Notes tab in the room's side panel. Notes save automatically as you type, and are never sent to the candidate: they only ever load for the interviewer who owns the interview.

Not yet. Use your usual video-call tool alongside Hire Pad. The participant tiles in the room only show who's connected.

Everyone in the room edits the same code in real time, and you'll see each other's cursors and selections labelled with names. The connection status is shown at the bottom of the screen; if it drops, you'll reconnect automatically and pick up the latest code.

JavaScript, TypeScript, Python, Java, C++, Go, Ruby, and SQL. Pick one from the language menu above the editor. That one runs on SQLite, so write queries in SQLite's dialect (syntax that only other database systems have won't work), and every run starts from the interview's database: the one the interviewer set up (see the Database tab), or an empty one if there is none, in which case create and fill the tables you need in the editor. If there's already code, you'll be asked to confirm, because switching replaces the code with that language's starter.

Select RUN CODE above the editor. Output appears in the Output tab for everyone in the room. The interviewer only sees output that was checked against the server's record of the run; if that check fails, the Output tab says so instead of showing it. To give your program input, type it into the stdin box in the Output tab before running.

Yes. Code runs in an isolated sandbox with no network access and a short time limit, so infinite loops are stopped and shown as timed out. Output is capped at 64 KB, input (stdin) at 64 KB, and source code at 200 KB. Each room can use RUN CODE up to 10 times every 30 seconds; the interviewer's RUN TESTS has its own allowance of 24 test cases in that time. If you hit a limit, the message says how many seconds to wait. When many people are running code at once, a run may wait a few seconds for its turn.

Select Whiteboard in the room header (and Code to switch back; each person switches independently). Draw with the pen, pick a color and size, or use the eraser to remove strokes. Undo only undoes your own strokes. Clear wipes the board for everyone, after you confirm. Drawings are saved with the room.

Yes. Drag the divider between the editor and the side panel, or focus it and use the left and right arrow keys. Your width is remembered in this browser.

Go to Question Library → New Question. Add a title, difficulty, language, tags, the prompt (Markdown, shown to the candidate), optional starter code, private solution notes, and up to 8 test cases.

If you see Draft with AI on the New question page, yes. Describe the question you want; the AI writes the prompt, starter code, test cases, and a reference solution (kept in your private solution notes), then runs its own solution against every test and keeps only the tests it passes. You review and edit everything before saving; nothing is saved until you do. Only the text you type and the draft are sent to the AI provider (OpenRouter); no candidate data is involved. A passing test shows that the AI's solution and tests agree, not that the question is good, so read it before you use it. Use is limited per person and per month.

If you see Draft feedback with AI under your notes in the room, yes. It sends your notes text (which may describe the candidate) to the AI provider (OpenRouter) and returns a structured draft: summary, strengths, concerns, questions to ask next, and what the notes don't cover. It only uses what's in your notes, never recommends hiring or rejecting, and is labelled as AI-generated. Nothing is saved or added to your notes until you select Add to notes; check it before you rely on it. Use is limited per person and per month.

Yes, if you tick Allow AI hints for the candidate when you create the interview or take-home. It's off by default and can't be turned on after the candidate has joined, because candidates are told on the join screen. They get a Hints tab where they can ask for a nudge: the AI is told never to give the answer, long code in its reply is removed, and it never sees your solution or hidden tests. Each interview allows a few hints, spaced apart. You see every hint, live in your own Hints tab and afterwards in the replay, with what the candidate asked. Their question, their current code, what their latest run printed (or its error) and the problem statement (never your solution or hidden tests) are sent to an AI provider.

Yes, if you tick Allow AI analysis of this session when you create the interview or take-home. It's off by default, and it can't be turned on after the candidate has joined, because candidates are told on the join screen when it's on. Afterwards, on the replay page, Summarise with AI sends the final code, the question, and the results of the code runs (never the candidate's name or email, or your notes) to an AI provider, and shows a summary of what the code shows, with what it couldn't see. It doesn't score or recommend anyone. The summary is kept so you don't pay twice, and is deleted with the recording; you can delete it or turn the setting off at any time.

Each test case feeds its input to the program on stdin and compares the output. Visible cases are shown to the candidate as examples. Hidden cases never reach the candidate's browser: when tests run, they only see pass or fail for each hidden case.

In the room's Prompt tab, choose a question and select Load. The prompt appears for both of you, the language switches to the question's, and the editor is replaced with its starter code (you'll be asked to confirm first). Select RUN TESTS to run every test case against the current code; results appear for both of you.

Write the schema and rows as SQL, and every run starts from them. For a single interview, open the room's Database tab (it appears when the language is SQL), type the setup, and select Save database. For a question you'll reuse, write it in the question's Database setup field; loading the question into a room, or sending it as a take-home, copies it onto that interview. Saving runs the setup first, so it must finish cleanly and print nothing (no SELECT), and a mistake is reported with SQLite's own message instead of breaking the interview later. It can be up to 100 KB, and lines can't start with a dot. Everything runs on SQLite, so use its dialect. The candidate sees the tables it creates and can query all of its data, so don't put anything private in it. Changes a run makes (an INSERT, a DELETE) don't carry to the next run, and a take-home keeps the database it was sent with even if you edit the question later. To start from a spreadsheet, use Import a CSV file above the setup: it adds a table and its rows to the setup for you to read and edit (the first row names the columns, empty values become NULL, and a sample of up to 1000 rows works better than a whole export).

Add them in the question's Test cases section like any other language, with two differences. A case's first box is extra data, not input: SQL (INSERT statements) that is added to the database for that case only, or nothing to use the setup as it is. Use it for the cases that break a wrong query: ties, NULLs, a customer with no orders. The second box is the rows the candidate's query must print: one row per line, columns separated by |, no header, NULL as empty. Tick Ignore the order of rows when the prompt doesn't ask for an ORDER BY; each expected row must still appear as many times as expected. Visible cases are shown to the candidate as examples; a hidden case's data and rows are never sent to the candidate, and only you can run tests. You can also ask Draft with AI to write the whole question: it writes the database and the cases, then runs its own query on every case and keeps only the ones whose rows it really gets.

Open the Database tab to see the tables your interviewer set up: their names and how they were created. Query them from the editor like any tables. Every run starts from that same database, so an INSERT or DELETE in one run doesn't carry over to the next. If the tab shows no tables, the interview starts from an empty database: create and fill the tables you need in the editor.

If your interviewer allowed them (you're told on the join screen), a Hints tab lets you ask an AI for a nudge when you're stuck. It won't give you the answer, and you get only a few. Your interviewer sees every hint you ask for and receive, and your question, current code, what your latest run printed (or its error) and the problem statement are sent to an AI provider to write it. Using a hint isn't cheating: it's part of this interview, and the interviewer knows about it.

Extra checks your interviewer can run against your code. You'll see whether each one passed or failed, but not its input or expected output. Use the visible examples in the Prompt tab to test your own solution.

Go to Take-homes → New Take-home. Choose a question from your library, set a time limit (5–480 minutes) and, optionally, a start by date. Copy the link and send it to the candidate. The list shows whether each one is not started, in progress (with time left), submitted (with time used), or expired.

The timer starts when you select Start take-home, and it keeps running even if you leave. Open the same link again and select Resume to carry on where you left off; your code is saved as you type.

Select Submit in the header when you're done. After that the code is read-only. If time runs out first, your work is submitted automatically.

In Take-homes, select Review on the row. It opens the session replay, with the time used shown against the limit. You can also open the take-home's room while it's in progress to watch live.

No. Take-homes only open from the take-home link, which is what keeps the timer fair.

Select the replay icon on an interview in Interviews, Replay under Recently completed on the dashboard, or Replay in the room header. Play it back at 1×, 4×, or 16×, or drag the slider to any point. Switch between Code and Whiteboard to see either at that moment, and select an item in the timeline (joins, leaves, runs) to jump to it.

Only the interviewer who created the interview. Candidates can't open replays. Replay shows the interviewer's notes as they were at the end.

Choose System, Dark, Light, Darcula (like PyCharm), or High contrast from the theme menu: in the dashboard sidebar, in the room's Settings (gear icon), or in a take-home's header. The editor switches with it. System follows your computer's light or dark setting.

Yes. Select the gear icon in the room header for font size, tab size, word wrap, and the minimap. These only affect you; other participants keep their own settings.

In your browser, so they follow you between rooms on the same browser but not to a different device or a private window.

Hire Pad reconnects automatically, and your code is kept. If it doesn't recover within a few seconds, reload the page and rejoin with the same name. Your access renews automatically every hour, so long interviews don't need a rejoin.

Compile errors and exceptions from your program appear in red in the Output tab, the same as a terminal, with the reason (such as Compilation Error or Runtime Error) and your program's exit code. If code has been run too often, the message says how many seconds to wait; if the code runner is busy, try again in a few seconds. Timed out means the program ran past the time limit, which is often an infinite loop or a program waiting for input you didn't give in stdin.

The display name you entered and when you joined and left; the code and whiteboard drawings in the room (saved every few seconds so the session can be replayed); the code you ran with its input and output; and what the interviewer entered about you (your name and email when they set up the interview, and their private notes). Only the interviewer who created the interview can see these. The recording, code runs, and notes are deleted automatically 180 days after the interview ends, and your name and email are removed from it at the same time; or everything goes straight away if the interviewer deletes the interview. An interview nobody finishes ends automatically after 7 days without activity. The privacy policy has the details.