What is the purpose of the `super` keyword in JavaScript classes?

0-2 years experience

1. 1You need to create a subclass `Dog` that extends `Animal` and wants to reuse the parent constructor to set `name`. How would you use `super` in the `Dog` constructor?
2. 2If you override a `speak()` method in a child class but still want to run the parent’s `speak()`, what syntax would you write and why?
3. 3What error do you get if you omit `super()` in a subclass constructor that defines its own constructor, and why does it occur?

2-5 years experience

1. 1We have a `User` base class with a `save()` method that logs to a database. A `PremiumUser` subclass overrides `save()` to also send a welcome email, but the code throws `this.save is not a function`. Walk me through why and how to fix it using `super`.
2. 2During a refactor we moved shared initialization logic into the parent class constructor. Some existing subclasses now break. Explain how you would adjust the subclass constructors with `super` to keep their behavior.
3. 3Discuss the trade‑offs of calling `super` at the start versus the end of a subclass constructor when you need to set up subclass‑only properties.

5-8 years experience

1. 1Our front‑end framework provides base components with lifecycle methods. A team wants to extend a base component and override `componentDidMount` but still run the base logic. How would you design the inheritance and use `super` to ensure correct ordering and avoid performance regressions?
2. 2We discovered that some classes call `super.method()` inside a tight loop, causing unnecessary work. How would you identify and refactor this pattern while preserving behavior?
3. 3When using mixins that also call `super` inside methods, method resolution order can become ambiguous. Discuss how you would structure class hierarchies or use composition to avoid super‑related bugs at scale.

8+ years experience

1. 1Our organization is migrating from prototype‑based inheritance to ES6 classes across multiple services. What guidelines would you set for using `super` to minimize breaking changes, especially concerning constructor signatures and method overrides?
2. 2Consider a micro‑frontend architecture where shared UI components are extended by different teams. How would you define a contract for `super` usage to ensure backward compatibility and avoid tight coupling?
3. 3If you need to support legacy browsers that don’t understand `super`, what strategies would you employ at the build or runtime level to preserve functionality across the whole platform?