Technical Interview Mode

Simulate real technical interviews on your code. Choose from several styles and get ready for any hiring process.

How does it work?

Choose an interview mode, explore real questions, and get ready to stand out in any technical process. Simulate an interactive interview on your own code or use it as a company to prepare questions and evaluate candidates in a practical and realistic way.

Classic Technical Interview (FAANG)

Questions about algorithms, data structures, and optimization. Professional and demanding tone. Includes follow-ups and complexity analysis.

Startup/Product Style

Questions about maintainability, scalability, and code quality. Friendly tone, focus on best practices and real-world experience.

Strict code reviewer / demanding mentor

Critical and direct tone. Fixes technical and style errors, asks incisive questions about decisions and design principles.

Interactive demo

Code:

interface Product {
  id: number;
  name: string;
  price: number;
  stock: number;
  discount?: number;
}

class Cart {
  private items: Product[] = [];

addItem(product: Product): void {
    if (product.stock <= 0) {
      throw new Error("Product is out of stock");
    }

const existing = this.items.find(p => p.id === product.id);
    if (existing) {
      existing.stock += 1;
    } else {
      this.items.push({ ...product, stock: 1 });
    }
  }

removeItem(productId: number): void {
    const index = this.items.findIndex(p => p.id === productId);
    if (index === -1) return;
    if (this.items[index].stock > 1) {
      this.items[index].stock -= 1;
    } else {
      this.items.splice(index, 1);
    }
  }

getTotal(): number {
    return this.items.reduce((total, item) => {
      const price = item.discount ? item.price * (1 - item.discount) : item.price;
      return total + price * item.stock;
    }, 0);
  }

checkout(userId: number): void {
    console.log("Saving order to database...");
    fetch("/api/save-order", {
      method: "POST",
      body: JSON.stringify({
        userId,
        items: this.items,
        total: this.getTotal()
      })
    }).then(() => {
      console.log("Order saved!");
    }).catch(() => {
      alert("Error while saving order");
    });
  }
}

// Frontend usage
const cart = new Cart();
const product: Product = { id: 1, name: "Laptop", price: 1200, stock: 3 };
cart.addItem(product);
cart.addItem(product);
cart.removeItem(1);
cart.checkout(42);

Generated question: 1

What data structure is used to store the products in the cart and why is it suitable?

Follow-up:

How would you change the structure if the product list became extremely large?

Expected answer:

The data structure used is an array of 'Product' objects. This is suitable for simple add and remove operations in small lists. However, if the product list became extremely large, you could consider using a 'Map' to improve search and update efficiency, as it provides O(1) access on average.

Generated question: 2

How would you handle cases where the stock of a product changes after it has been added to the cart?

Follow-up:

What problems could arise if real-time stock is not handled properly?

Expected answer:

You could implement a periodic or real-time update mechanism for the product stock before proceeding to checkout to ensure there is enough stock. If not handled properly, issues such as overselling or order processing errors could occur.

Generated question: 3

How would you test this 'Cart' class? Describe some unit test cases.

Follow-up:

What tools would you use to automate these tests?

Expected answer:

I would test the 'addItem', 'removeItem', and 'getTotal' methods. For example, I would check that 'addItem' increases the stock correctly and that 'removeItem' decreases it. I would also test edge cases such as adding a product with no stock. I would use tools like Jest or Mocha to automate these tests.

Generated question: 4

How would you improve the 'checkout' method to better handle network errors?

Follow-up:

How would you implement a retry mechanism in case of failure when saving the order?

Expected answer:

I could improve error handling using a 'try-catch' block and adding an exponential retry mechanism with a maximum number of attempts. This could be implemented with a recursive function or by using a retry handling library like 'axios-retry'.

Generated question: 5

How would you extend this class to support discount coupons applied to the cart total?

Follow-up:

What structural changes would be necessary to support multiple types of coupons?

Expected answer:

I would add a new method to apply coupons to the cart total, storing the coupons in an additional property. To support multiple types of coupons, I could use a strategy pattern that allows defining different discount behaviors depending on the coupon type.

Generated question: 6

How would you ensure this code is scalable and maintainable as the business grows?

Follow-up:

What design patterns could you apply to improve scalability?

Expected answer:

To ensure scalability and maintainability, I would modularize the code by dividing responsibilities into different classes or services. I would apply design patterns such as the repository pattern for data management and the factory pattern for creating complex objects.

Evaluation

This set of questions evaluates the candidate's understanding of data structures, error handling, unit testing, scalability, and code extensibility. The candidate is expected to identify and propose improvements in both efficiency and design, and to have a proactive approach to anticipating future problems.