AppsTechnical Interviews

// Autessa Technical Interviews · technical interview software

Live coding interviews where you both write and run the code.

Autessa Technical Interviews is live coding interview software. Keep a question bank, send each candidate a private link, and write and run Python or Java together in one shared editor. Afterward, review the final code, every run and your private notes. It works out of the box, and because it lives in Autessa, it fits the way your team already hires.

  • Shared editor
  • Python 3.12
  • Java 21
  • Question bank
  • No candidate account
  • Run history
Technical interview · Jordan LeeLiveSAMPLE
Jordan Lee · Candidate connectedCopy candidate linkClose linkReview
Python 3.12 ▾✓ SavedA− A+ · Focus · Output
def two_sum(nums, target):
seen = {}
for i, n in enumerate(nums):
if target - n in seen:Candidate
return [seen[target - n], i]
seen[n] = i
return []
print(two_sum([2, 7, 11, 15], 9))Interviewer

Languages

Python 3.12 and Java 21

Candidate access

Private link, no account

Code execution

Both sides, up to 2 minutes a run

Question bank

Markdown prompts, starter code, notes

Review

Final code, every run, notes

// what is technical interview software?

One room for the whole coding interview, for your team and your candidates.

Technical interview software gives an interviewer and a candidate a shared place to write, run and talk through code. Autessa Technical Interviews has two halves that work as one product: an interviewer console with the question bank, sessions, the live room and review, and a candidate coding room that opens from a private link.

Autessa Technical Interviews includes a collaborative code editor, Python and Java code execution, a technical interview question bank, private candidate links you can close at any time, interviewer notes, and a review page with the full run history of every interview.

// what makes it different

The details that make a coding interview fair, calm and easy to judge.

Every coding interview tool has an editor. These are the parts that Autessa sweats, because they change how the interview feels and how good your decision is.

Live coding room

Shared output console

Every run in the room lands in one shared output console that both the interviewer and the candidate see, labeled with who ran it, its exit status and how long it took.

Explore →
Live coding room

Focus mode and room layout

Focus mode leaves just the code and the output on screen, and the question pane and output panel collapse or resize, remembered per browser.

Explore →
Live coding room

Presence and reliable sync

The room shows whether the other person is connected and whether your code is saved; if the connection drops, typing keeps working and syncs as soon as it is back.

Explore →
Question bank

Interviewer notes on questions

Every bank question can hold private interviewer notes, such as hints, the expected solution and follow-ups, shown beside the live room and never sent to the candidate.

Explore →
Question bank

Question snapshots

When a question is added to a session, its title and prompt are copied in, so editing the bank later never rewrites what a past candidate was asked.

Explore →
Interview sessions

Private candidate links

Each session has a private candidate link that the interviewer copies in one click, can close to end the candidate’s access instantly, and can reopen later.

Explore →
Interview sessions

Multi-question interviews

One session can hold several questions: the interviewer switches the question on screen for both people with one click and can add a bank or blank question mid-interview.

Explore →
Candidate experience

Submit and lock

When the candidate submits, their editor turns read-only and the interviewer is told the time; the interviewer can turn editing back on with one click.

Explore →
Candidate experience

What’s available and clear limits

A “What’s available” panel lists the installed libraries and the run time limit, and every limit or link problem is explained to the candidate in plain language.

Explore →
Review and decisions

Run history

Run history keeps every run from the interview with who ran it, the exact code, the input, the output, any errors, the exit status and how long it took.

Explore →

// product tour · for your team

Every screen of the interviewer console.

Two places in the navigation, Sessions and Questions, and everything an interview needs inside them.

sessions

See every interview at a glance.

The sessions list shows each coding interview with its candidate, a Live, Open, Submitted or Closed status, when it was created and when the candidate was last active. Every column sorts, and Live badges stay current on their own.
  • “Not opened yet” until the candidate joins
  • Click a row to open its live room
  • Rows stack neatly on a phone
Explore see every interview at a glance →
Sessions+ New sessionSAMPLE
Session ↕Candidate ↕Status ↕Created ↕Last candidate activity ↕
Backend engineer interviewJordan LeeLive12 min agoJust now
Data engineer onsitePriya RamanSubmitted2 hours ago1 hour ago
Intern coding roundSam OrtizOpenYesterdayNot opened yet
Platform engineerAlex KimClosedLast weekLast week

new session

Set up an interview in a minute.

Enter the candidate’s name and an optional email, choose Python, Java or both, and pick questions from your bank in the order you will ask them. Or skip the questions and add them during the interview.
  • Reorder or remove picked questions
  • The first language is where every question starts
  • You land in the live room, ready to copy the link
Explore set up an interview in a minute →
New sessionCreate sessionSAMPLE

Candidate

Candidate name

Jordan Lee

Candidate email (optional)

jordan@example.com

Session title

Backend engineer interview

Languages

☑ Python 3.12   ☑ Java 21

The first one is where every question starts.

Questions, in the order you’ll ask them

1Two sumEasy↑ ↓ ✕
2Merge intervalsMedium↑ ↓ ✕

Question bank

Balanced brackets+ Add
LRU cache+ Add
Rate limiter+ Add

live room

A code-first room with everything you need beside it.

The editor takes the screen. Beside it: the question rail with the one on screen marked, that question’s private notes, and your own notes that save as you type. Copy the candidate link, close it, reopen it, or jump to the review.
  • Put any question on both screens with one click
  • Add a bank or blank question mid-interview
  • Focus mode leaves just the code and the output
Explore a code-first room with everything you need beside it →
Live room · questionsSAMPLE
1Two sum
2Balanced bracketsON SCREEN

Add a question

Warm-up: reverse a stringAdd blank

or pick from your bank

LRU cache+ Add
Merge intervals+ Add

review

Review exactly what happened.

Each question shows the prompt the candidate read, its interviewer notes and the final code in every language they used. The run history lists every run with who ran it, the exact code, the input, the output and the errors.
  • Timeline: created, opened, submitted, link closed
  • Private notes stay editable
  • Expand any run to see the exact code that ran
Explore review exactly what happened →
Review · Backend engineer interviewOpen live roomSAMPLE

Question 1

Two sum

▸ Show prompt
Python 3.12 · final code
def two_sum(nums, target):
seen = {}
for i, n in enumerate(nums):
if target - n in seen:
return [seen[target - n], i]
seen[n] = i
return []
print(two_sum([2, 7, 11, 15], 9))

questions

A question bank your whole team shares.

Store every coding question with a difficulty, tags and private interviewer notes. Sort, search, archive and restore. Start from sample questions if the bank is empty.
  • Editing a question never changes a past interview
  • Archived questions leave the picker, not your history
Explore a question bank your whole team shares →
Questions · your question bank+ New questionSAMPLE
⌕ Search by title or tag☐ Show archived (2)
Title ↕Difficulty ↕TagsUpdated ↕
Two sumEasyarrayshash maps2 days ago
Balanced bracketsEasystacksstrings2 days ago
Merge intervalsMediumsortingarrayslast week
LRU cacheMediumdesignhash mapslast week
Rate limiterHarddesignqueues3 weeks ago

question editor

Write prompts in Markdown, see what candidates see.

Headings, bold, inline code, code blocks and lists, with a side-by-side preview. Add separate Python and Java starter code and the notes only interviewers will read.
Explore write prompts in markdown, see what candidates see →
Edit question · Merge intervalsMediumSAMPLE

Prompt · Markdown

# Merge intervals
Given a list of `[start, end]` pairs,
merge every overlap.

## Example
```
[[1,3],[2,6],[8,10]]
→ [[1,6],[8,10]]
```

- **Sort first** if you like

Preview · what the candidate reads

Merge intervals

Given a list of [start, end] pairs, merge every overlap.

Example

[[1,3],[2,6],[8,10]]
→ [[1,6],[8,10]]

• Sort first if you like

// product tour · for your candidates

A calm coding room that opens from one link.

Candidates do not create an account or install anything. They open the link you send and start coding, with the question beside them and their work saving as they type.

candidate coding room

Read, code, run. Nothing in the way.

The question sits beside an editor with autocomplete, bracket matching and search. Candidates run their code, add program input, and see the output and errors below. They can switch between the allowed languages and choose a light or dark theme.
  • “What’s available” lists every installed library
  • Plain-language messages for every limit
  • Shows whether the interviewer is connected
Explore read, code, run. nothing in the way →
Autessa coding interviewInterviewer connectedSAMPLE

Backend engineer interview

Your work saves automatically. Your interviewer sees your code as you type.

➤ Submit

Question 2 of 2

Balanced brackets

Return true if every bracket in s is closed in the right order.

Example

"([]{})"  → true
"(]"      → false
Java 21 ▾✓ Saved▶ Run
import java.util.ArrayDeque;
public class Main {
static boolean balanced(String s) {
var stack = new ArrayDeque<Character>();
for (char c : s.toCharArray()) {
if (c == '(') stack.push(')');
else if (stack.isEmpty() || stack.pop() != c) return false;
}
return stack.isEmpty();
}
}

submit

A clear finish line, and an undo for you.

When the candidate submits, their editor turns read-only and you see the time. Your editor still works, and one click lets the candidate edit again if they submitted early.
Explore a clear finish line, and an undo for you →
Candidate · submitSAMPLE

Submit your work?

Your code is saved and shared with your interviewer. After you submit, you can’t edit or run it anymore.

Keep workingSubmit
Interviewer · live roomSubmittedSAMPLE

The candidate submitted at 11:24. Their editor is read-only; yours still works.

↶ Let the candidate edit again

// how it works

From question bank to hiring decision.

  1. 01

    Write your questions

    Build a question bank with Markdown prompts, Python and Java starter code, a difficulty, tags and private notes for interviewers.

    Learn more →
  2. 02

    Create a session

    Add the candidate, choose the languages and pick questions in order. Copy the private candidate link and send it.

    Learn more →
  3. 03

    Code together, live

    Both of you type in one editor and run the code. Switch questions, add one on the fly, and take private notes.

    Learn more →
  4. 04

    Review and decide

    See the final code per question and language, every run with its output, the timeline and everyone’s notes.

    Learn more →

// everything in technical interviews

Every area, every feature.

The whole coding interview, area by area. Each feature has its own page with how it works, every option and who can do what.

01

Live coding room →

The live coding room is one shared editor where the interviewer and the candidate write, run and discuss the same Python or Java code in real time.

02

Question bank →

The question bank holds every coding question your team asks, with the prompt the candidate reads, starter code and notes only interviewers see.

03

Interview sessions →

A session is one live coding interview with one candidate: the questions in order, the languages allowed and a private link you control.

04

Candidate experience →

Candidates join from a private link into a calm coding room that saves as they type, shows what is installed, and lets them submit when they are done.

05

Review and decisions →

Review shows exactly what happened in the interview: final code per question and language, every run, the timeline and the interviewer’s private notes.

// who it is for

Built for everyone in the loop.

Engineering teams, recruiters, bootcamps and agencies use the same room in different ways.

Explore use cases by role and industry →

Engineering managers

One shared question bank and the same room for every interviewer, so loops are consistent and comparable.

Interviewers

A code-first room with question notes beside you, a shared console, and private notes that save themselves.

Recruiters and coordinators

Create a session in a minute, see who has opened their link, and know which interviews are ready for review.

Candidates

One link, no account, a calm editor with autocomplete, and a clear Submit when they are done.

// security and privacy

Candidates see the question. Nothing else.

The candidate room can only open the session, sync code, run it and submit. Every action checks the session link and returns only what a candidate should see. Your question bank and notes never leave the interviewer console.

Link-checked actions only

No direct access to your data from the candidate side.

Close a link instantly

Access ends the moment you click Close link.

Key out of the address bar

The link’s key moves into the tab on arrival, away from history and screenshots.

Private notes stay private

Question notes and session notes are never sent to the candidate.

// compare

Evaluating CoderPad, HackerRank, CodeSignal or Karat?

Side-by-side grids that show where Autessa comes out ahead, from the live room to running all of your hiring on one platform.

// faq

Questions about Autessa Technical Interviews

Does Autessa have technical interview software?

Yes. Autessa Technical Interviews is live coding interview software: you keep a question bank, send each candidate a private link, and you both write and run Python or Java in one shared editor. Afterward you review the final code, every run and your private notes.

Can candidates run code during the interview?

Yes. Both the candidate and the interviewer can run Python 3.12 or Java 21 code from the room, with optional program input. Every run appears in a shared output console with who ran it, the exit status and how long it took. Programs stop after two minutes.

Which programming languages are supported?

Python 3.12 and Java 21. Python includes the standard library plus numpy, pandas, sortedcontainers and more-itertools. Java includes the standard library plus Guava, Apache Commons Lang 3, Apache Commons Collections 4 and Gson, in a single file where the first top-level class runs. You choose which of the two each session allows.

Do candidates need an account or a download?

No. The candidate opens the private link you send and starts coding in the browser. Their work saves automatically, and they can switch between a light and a dark theme.

Can I use my own coding questions?

Yes. You build your own question bank with a Markdown prompt, separate Python and Java starter code, a difficulty, tags and private interviewer notes. You can start from sample questions and archive questions you retire.

Can the interviewer see what the candidate types in real time?

Yes. Interviewer and candidate edit the same document, so each sees the other’s typing within about a second, and each person’s cursor stays where it was. The room also shows whether the other person is connected.

How do I end a candidate’s access?

Close the link. One click in the live room closes the candidate link immediately; the candidate sees that the session has ended and their work stays saved. You can reopen the same link later if you need to.

What can I review after the interview?

Everything that happened. The review page shows each question’s prompt and the candidate’s final code in every language they used, the full run history with code, input, output and errors, the session timeline, and your private notes.

Are interviewer notes hidden from candidates?

Yes. Notes on a question (hints, the expected solution, follow-ups) and notes on a session are only in the interviewer console. Every candidate action checks the link and returns only what a candidate should see, so notes are never sent to the candidate room.

Does it work out of the box?

Yes. Start with the sample questions and run your first interview the same day. Because it runs in Autessa, you can shape it to how your team hires: your own questions, the languages each session allows, who can open the console, and the hiring decision in Autessa Recruit.

How does it work with our video calls?

Run the conversation on the video tool your team already uses and the code in Autessa Technical Interviews: a shared editor, code execution, the question bank and a full review of every run, judged by your interviewers with their notes.

$ start --interview

Run your next coding interview in Autessa.

Use it out of the box: write a question, create a session, send the link. Then shape it to how your team interviews, all inside Autessa.

100% customizable, code and all

Make Autessa Technical Interviews fully your own.

Use it out of the box, then change anything. Ask Autobot, Autessa’s AI builder, for a new field, screen, report, workflow or agent and it builds it into your copy of the app. Or open the code and edit it yourself. Nothing is locked: the app, its data and its code are yours.

Start free and make it yours