Interview Questions & Practice Timer

Give a 60 to 90 second story: who you are now (course and college), one or two things you have done (a project, a skill), and why you want this role. Do not recite your whole life or your resume.

Show you did your homework: one thing about the company's work, product or culture that you like, and how it fits what you want to learn. Avoid answers that would fit any company.

Pick two or three strengths that matter for this job and prove each with a short example. Saying you are hard-working means little without a story behind it.

Name a real, small weakness, not a disguised strength, and say what you are doing about it. For example, you rush to code before planning, so you now write a short plan first.

Talk about growth in skills and responsibility, not a specific title. Show you want to learn and stay, while being realistic for the role.

Match your skills and projects to what the job needs, in two or three points. Be confident but not boastful, and mention your eagerness to learn.

Give your honest reason with a real moment or interest, and link it to what you have done since. If it was not your first choice, say what you found worth doing in it.

Answer honestly. If yes, say so simply. If you have a real limit, explain it politely and say what you can do, rather than promising something you will not keep.

For a fresher, say you are open to the company's standard range for the role and more interested in learning. If pressed, give a range based on research of similar roles, never a number you cannot defend.

Always ask two or three: what the first months look like, how the team learns and gives feedback, what success in the role means. Avoid asking about leave or salary first.

Summarise what the company does, its products or customers, and one recent thing you read about it. Say how that connects to the role you applied for.

Describe your method, such as breaking work into small steps and asking for help early, and add a short example of a deadline you met.

Be honest and brief, then move to what you learned or did in that time, such as a course, preparation or family responsibility. Do not sound defensive.

Pick real ones, and where possible link them to useful qualities such as teamwork from sport or patience from chess. Be ready for a follow-up question about them.

Read the terms before the interview or ask for them. Say you understand it, and ask about the duration and conditions, because a bond is a serious commitment.

Use STAR. Describe the team goal, your own role, what you did to help it succeed and the result. Say what you did, not only what the team did.

Show how you planned: what you cut or put first, how you used your time, and what the outcome was. Interviewers want to see calm planning, not panic.

Pick a real but small mistake, own it without blaming anyone, say how you fixed it and what you do differently now. The learning is the point of the answer.

Explain the problem clearly, the steps you tried, why you chose your solution and what changed. A debugging story from a project works well.

Leadership can be small: organising an event, guiding juniors, driving a project. Show how you got others to work together and the result.

Show that you listened, explained your view calmly and found a way forward. Do not make the other person the villain.

Say what you had to learn, how you went about it (courses, practice, asking people) and what you did with it. This shows you can grow on the job.

Pick a moment where your help made a difference, such as teaching a friend a subject. It shows you are a good team member.

Choose a real failure, say what you learned and what you did next. Interviewers respect honesty more than a story that is secretly a success.

Say you listen first, ask for specifics and act on it, and add a short example where feedback improved your work.

Describe the extra step you took on your own, why you took it and what it led to. It shows initiative.

A list is mutable and a tuple is immutable. Tuples are slightly faster, can be used as dictionary keys if their items are hashable, and suit fixed records. Lists suit collections that change.

It is a hash table that maps keys to values, with average constant-time lookup. Keys must be hashable, and since Python 3.7 a dictionary keeps insertion order.

*args collects extra positional arguments into a tuple and **kwargs collects extra keyword arguments into a dictionary. They let a function accept any number of arguments.

A function that takes a function and returns a new one that adds behaviour, such as logging or timing, without changing the original code. It is written with the @ syntax.

== checks whether two values are equal, while is checks whether they are the same object in memory. Use is for None checks, and == for comparing values.

A short way to build a list from another sequence, like [x * x for x in numbers if x > 0]. It is usually clearer and faster than a loop that appends.

Mainly by reference counting, where an object is freed when nothing refers to it, plus a garbage collector that finds reference cycles. Python also pools small objects.

A shallow copy copies the outer object but shares the inner objects, so changing a nested item shows in both. A deep copy copies everything inside too. Use copy.deepcopy for nested data.

Functions that use yield to produce values one at a time instead of building a whole list. They save memory and are good for large or endless streams of data.

The Global Interpreter Lock in CPython lets only one thread run Python bytecode at a time. Threads still help with waiting on input and output, but for heavy computation use multiprocessing.

The default value is created once when the function is defined, so a default list is shared between calls. Use None as the default and create the list inside the function.

The JVM runs compiled bytecode, the JRE is the JVM plus the standard libraries needed to run programs, and the JDK adds the compiler and tools needed to develop them.

== compares references for objects, meaning whether they are the same object. equals() compares content when a class overrides it, as String does. Compare strings with equals().

An abstract class can hold state and partly implemented methods and a class extends only one. An interface describes a contract and a class can implement many. Since Java 8 interfaces can have default methods.

Overloading is the same method name with different parameters in one class, decided at compile time. Overriding is a subclass giving its own version of a parent's method, decided at run time.

Immutability makes strings safe to share, cache and use as keys. The string pool stores one copy of each literal, so equal literals can share memory. Use StringBuilder when you change text a lot.

Checked exceptions must be handled or declared, such as IOException. Unchecked ones extend RuntimeException, such as NullPointerException, and the compiler does not force handling them.

It uses the key's hashCode to pick a bucket and equals to find the key inside it. Collisions go into a list, which becomes a tree when it grows long in Java 8 and later. It resizes as it fills.

ArrayList uses an array, so reading by index is fast and inserting in the middle is slow. LinkedList is fast at inserting and removing at known positions but slow at reading by index.

The JVM automatically frees memory of objects that nothing refers to any more. You cannot force it, only suggest it, and good code avoids keeping references it no longer needs.

final marks a variable, method or class that cannot change or be overridden. finally is a block that always runs after try and catch. finalize was a method called before garbage collection and is now deprecated.

WHERE filters rows before grouping and cannot use aggregate functions. HAVING filters groups after GROUP BY and can use aggregates such as COUNT or SUM.

INNER JOIN returns only rows that match in both tables. LEFT JOIN returns every row of the left table and fills the right table's columns with NULL where there is no match.

A primary key identifies each row uniquely and cannot be NULL. A unique key also stops duplicates but allows a NULL. A foreign key points to a primary key in another table to link them.

Organising tables to reduce repeated data and mistakes. First normal form has single values in each cell, second removes partial dependencies and third removes dependencies between non-key columns.

DELETE removes chosen rows and can be rolled back. TRUNCATE removes all rows quickly and keeps the table. DROP removes the whole table and its structure.

An index is a structure that makes searches on a column faster. It speeds up reads but slows inserts and updates and uses space, so index the columns you filter and join on, not everything.

Atomicity (all or nothing), Consistency (rules always hold), Isolation (transactions do not disturb each other) and Durability (committed data survives a crash). They keep transactions reliable.

One way is to select the maximum salary below the overall maximum, using a subquery. Another is to use DENSE_RANK or LIMIT with OFFSET. Mention duplicates and what you want when two people share a salary.

A subquery is a query inside another, a join combines tables side by side. Joins are often faster and clearer, while subqueries can be easier to read for simple filters.

A saved query that behaves like a virtual table. It hides complexity, can restrict what users see and does not store data itself, unless it is a materialised view.

An array has fixed-size, contiguous memory and fast access by index. A linked list has nodes joined by pointers, so inserting and removing is easy but reaching an item means walking the list.

A stack is last in, first out, used for undo and function calls. A queue is first in, first out, used for scheduling and breadth-first search.

How the running time grows with the input size, written in Big-O. Array access is O(1), binary search O(log n), a single loop O(n), good sorts O(n log n) and nested loops O(n squared).

On a sorted list, check the middle item and discard the half that cannot hold the target, repeating until found. It takes O(log n) time and needs the data sorted.

Use two pointers, one moving one step and the other two steps. If they ever meet there is a cycle, and if the fast one reaches the end there is none. It uses constant extra memory.

A function that calls itself on a smaller version of the problem. The base case stops the calls, and without it the function runs until the stack overflows.

BFS visits nodes level by level using a queue and finds the shortest path in an unweighted graph. DFS goes deep first using a stack or recursion and is useful for paths, cycles and ordering.

Two keys can map to the same slot. Chaining keeps a list in each slot, and open addressing looks for another free slot. A good hash function and resizing keep lookups close to constant time.

Merge sort is always O(n log n) and stable but needs extra memory. Quick sort is O(n log n) on average with little extra memory, but its worst case is O(n squared) with bad pivots.

A tree where each node's left side holds smaller values and its right side larger ones. Searching, inserting and deleting take O(log n) when it is balanced, but a skewed tree degrades to O(n).

Every element is a box made of content, padding, border and margin. Knowing it explains an element's real size, and box-sizing: border-box makes width include padding and border.

Block elements start on a new line and take the full width. Inline elements flow in the text and ignore width and height. Inline-block flows inline but accepts width and height.

Flexbox arranges items in one direction, a row or a column, and suits menus and cards. Grid lays out rows and columns together and suits whole page layouts.

Using elements for their meaning, such as header, nav, main and button. It helps accessibility, search engines and readable code, compared with using div for everything.

var is function-scoped and hoisted with an undefined value. let and const are block-scoped, and const cannot be reassigned. Prefer const, and let when the value changes.

A function that remembers the variables of the place where it was created, even after that place has finished running. It is used for private data and callbacks.

== converts types before comparing, which gives surprises such as 0 == '0'. === compares value and type with no conversion, so it is the safer choice.

A promise stands for a value that will arrive later. async/await is a cleaner way to write code that waits for promises, and errors are handled with try and catch.

The browser finds the server's address through DNS, opens a connection, sends an HTTP request, receives the HTML, and then loads CSS and scripts and draws the page.

Use flexible layouts such as Flexbox and Grid, relative units, images that scale and media queries for different screen widths, and test on a real phone.

Encapsulation (hiding data inside objects), abstraction (showing only what is needed), inheritance (reusing a parent's behaviour) and polymorphism (one interface, many forms). Give a small example of each.

A process is a running program with its own memory. Threads live inside a process and share its memory, which makes them lighter but needs care to avoid clashes.

Two or more processes each hold a resource and wait for another's, so none can continue. It needs mutual exclusion, hold and wait, no pre-emption and circular wait. Break one of these, for example by always taking locks in the same order.

A technique that lets a program use more memory than the computer physically has by moving unused pages between RAM and disk. It also isolates programs from each other.

TCP is reliable, ordered and connection-based, used for web pages and email. UDP is faster with no delivery guarantee, used for video calls and games.

Physical, data link, network, transport, session, presentation and application. Be ready to place familiar things on them, such as IP on the network layer and HTTP on the application layer.

A way for programs to talk over HTTP using URLs for things and methods such as GET, POST, PUT and DELETE for actions. Each request carries all it needs, and data is often sent as JSON.

A compiler translates the whole program to machine code before it runs. An interpreter reads and runs it line by line. Many languages, such as Java and Python, use a mix.

The stack holds function calls and local variables and is fast and automatically managed. The heap holds objects that live longer and is managed by the programmer or a garbage collector.

Git tracks changes to code. Merge joins two branches and keeps both histories, while rebase replays your commits on top of another branch for a straight history. Do not rebase shared branches.

SQL databases store data in tables with a fixed structure and relations. NoSQL databases, such as document or key-value stores, are more flexible and scale across machines easily. Choose by the data and the queries.

Authentication checks who you are, for example with a password. Authorisation decides what you are allowed to do once you are known.

VLOOKUP looks only to the right of the lookup column and breaks when columns move. INDEX-MATCH and XLOOKUP can look in any direction and are more flexible and robust.

A tool to summarise a large table by dragging fields into rows, columns and values, such as total sales by region and month. It answers questions quickly without formulas.

Check for missing values, duplicates, wrong types and outliers, fix or remove them with clear rules, standardise formats and keep a note of every change so the result can be repeated.

When the data has extreme values, such as salaries or house prices. The median is not pulled by outliers, so it describes a typical value better.

Correlation means two things move together. Causation means one causes the other. Ice cream sales and drowning both rise in summer, but one does not cause the other.

Supervised learning trains on labelled examples to predict an answer, such as spam or not spam. Unsupervised learning finds structure in unlabelled data, such as grouping similar customers.

A model that learns the training data too closely, including noise, and does badly on new data. Reduce it with more data, a simpler model, regularisation and checking on a separate test set.

A key performance indicator is a measure of progress towards a goal. Choose one that is tied to the goal, measurable, and something the team can influence, such as a conversion rate rather than just page views.