Exposys Data Labs — Developer Prep Pack

Technical Written Test — Practice MCQs

Format per JD: Logic, Programming, Case-based MCQs. Answers are in the collapsible below each. Try first, then check.

Programming Output MCQs

Logic & Reasoning MCQs

Coding problems to write from scratch tonight

• Reverse a string / array (JS: s.split('').reverse().join(''))
• Check palindrome (numbers and strings)
• Find the first non-repeating character in a string
• Count frequency of elements in an array (use a HashMap / object)
• Remove duplicates from an array
• Two-sum: find a pair that adds up to a target
• FizzBuzz / prime check / factorial / Fibonacci (iterative + recursive)

Full Stack Developer — Core Knowledge

Per the JD, the required stack is HTML/CSS/JavaScript + (React/Angular) + (Node/Java/Python) + (MySQL/PostgreSQL/MongoDB) + REST APIs. Know each layer well enough to explain "how a request flows."

Frontend — HTML / CSS / JavaScript

• HTML5: semantic tags (header, nav, main, section, footer), forms & input types, accessibility (alt text, labels).
• CSS: box model, Flexbox vs Grid, specificity, media queries (responsive), units (px vs rem vs %).
• JavaScript: var/let/const, arrow functions, template literals, destructuring, map/filter/reduce, === vs ==, closures, promises & async/await, DOM events.

React fundamentals high priority

• Components — functional components; props passed from parent to child.
• State — useState hook; immutable updates.
• Effects — useEffect for data fetching / side effects; dependency array.
• JSX — HTML-like syntax; className instead of class.
• Virtual DOM — why React is fast; reconciliation.
• Lists & keys — key prop for rendering arrays.
• Conditional rendering — ternary / && operators.

function UserList() {
  const [users, setUsers] = useState([]);

  useEffect(() => {
    fetch("/api/users")           // GET request to backend
      .then(r => r.json())
      .then(data => setUsers(data));
  }, []);

  return <ul>{users.map(u => <li key={u.id}>{u.name}</li>)}</ul>;
}

Backend — Node.js / Express (or Java / Python)

• Node.js — JS runtime on the server; event-driven, non-blocking I/O.
• Express — routing: app.get / app.post / app.put / app.delete.
• Middleware — functions that run between request and response (auth, body-parser, logging).
• Controllers & routing — separate business logic from routes.
• Environment variables — keep secrets (DB passwords, JWT keys) in .env.
• Error handling — try/catch + centralized error middleware.

const express = require("express");
const app = express();
app.use(express.json());

app.get("/api/users", async (req, res) => {
  const users = await db.query("SELECT * FROM users");
  res.status(200).json(users);
});

app.post("/api/users", async (req, res) => {
  const { name, email } = req.body;
  const u = await db.query("INSERT INTO users(name,email) VALUES(?,?)", [name, email]);
  res.status(201).json(u);
});

app.listen(3000);

REST API — must-know

REST = Representational State Transfer. Uses HTTP verbs + URLs; stateless; usually exchanges JSON. Example resource path: GET /api/products/12 returns product #12.

Git & version control (good-to-have, but easy points)

git init
git add .
git commit -m "initial commit"
git branch feature-login
git checkout feature-login
git merge feature-login
git push origin main
git pull

SQL & Database Fundamentals

JD names MySQL / PostgreSQL / MongoDB. SQL will almost certainly appear in the written test and interview.

Core SQL clause order

SELECT   columns
FROM     table
WHERE    condition
GROUP BY columns
HAVING   condition_on_aggregates
ORDER BY column ASC|DESC
LIMIT    n;

The five joins — know them cold

-- INNER JOIN: only matching rows in both tables
SELECT * FROM orders o
INNER JOIN users u ON o.user_id = u.id;

-- LEFT JOIN: all rows from left, NULLs where no match on right
SELECT * FROM users u
LEFT JOIN orders o ON u.id = o.user_id;

-- RIGHT JOIN: all rows from right table
-- FULL JOIN: all rows from both (NULLs where no match)
-- SELF JOIN: table joined to itself (e.g. employee -> manager)

Classic interview queries

-- 1. Second highest salary
SELECT MAX(salary) FROM employees
WHERE salary < (SELECT MAX(salary) FROM employees);

-- 2. Find duplicate records
SELECT name, COUNT(*) AS cnt
FROM employees
GROUP BY name
HAVING COUNT(*) > 1;

-- 3. Employees earning above their department average
SELECT * FROM employees e
WHERE salary > (
  SELECT AVG(salary) FROM employees
  WHERE dept_id = e.dept_id
);

-- 4. Top 3 highest-paid per department (Postgres, window fn)
SELECT * FROM (
  SELECT *, RANK() OVER (PARTITION BY dept_id ORDER BY salary DESC) rk
  FROM employees
) t WHERE rk <= 3;

-- 5. Count of orders per user
SELECT u.name, COUNT(o.id) AS total
FROM users u LEFT JOIN orders o ON u.id = o.user_id
GROUP BY u.name;

DBMS concepts

• Keys: primary (unique + non-null), foreign (references another table), candidate, composite.
• Normalization: 1NF (atomic values) → 2NF (no partial dependency) → 3NF (no transitive dependency).
• ACID: Atomicity, Consistency, Isolation, Durability.
• Index: speeds up reads, slows writes; created on frequently-filtered columns.
• Transactions: BEGIN / COMMIT / ROLLBACK.

SQL vs NoSQL (MongoDB)

• SQL — structured tables, fixed schema, strong relationships, vertical scaling.
• MongoDB — documents (JSON-like), flexible schema, horizontal scaling. Collections instead of tables, documents instead of rows.

Data Science Role (in case you also apply)

The JD for Role 1: Data Scientist requires Python, Pandas/NumPy/Scikit-learn, SQL, and ML concepts.

Python data stack

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

df = pd.read_csv("data.csv")
df = df.dropna()
X = df[["area", "rooms"]]
y = df["price"]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

model = LinearRegression().fit(X_train, y_train)
preds = model.predict(X_test)
print(mean_squared_error(y_test, preds))

ML concepts to know

• Supervised learning — labeled data. Regression (continuous, e.g. price) vs Classification (categories, e.g. spam).
• Unsupervised — no labels. Clustering (K-Means) groups similar items.
• Train/test split — evaluate on unseen data to check generalisation.
• Overfitting vs underfitting — too tuned to train data vs model too simple.
• Metrics: Accuracy, Precision, Recall, F1, RMSE.
• Feature engineering — creating useful inputs from raw data.

Statistics & Probability

• Mean, median, mode; variance & standard deviation.
• Normal distribution; correlation vs causation.
• Basic probability: independent events, conditional probability, Bayes' idea.
• Bias, data leakage, model drift (mentioned in JD as "good to have").

Case-Based Questions — Framework

The written test has case-based MCQs and the interview may pose a practical scenario. Speak/answer in this order:

1. Understand the problem — restate it in your own words.
2. Clarify — ask 1–2 questions (constraints, users, scale).
3. Break it down — list features/components.
4. Choose an approach — tech stack for a dev case; model for a DS case.
5. Trade-offs — mention alternatives (e.g. SQL vs NoSQL, or which ML algorithm and why).
6. Conclude — a clear recommendation.

Example: "Design a simple 'to-do app' end-to-end."

Example: "Sales dropped 20% last quarter. How would you investigate?"

Example: "Estimate the number of cars in Bengaluru."

Technical Interview + HR

Technical interview — expect

• Explain one of your projects end-to-end: problem, stack, your role, challenges, what you'd improve.
• Write a small function live — reverse a string, find duplicates, FizzBuzz, basic array operations.
• Explain REST, an API request flow, the difference between frontend and backend.
• Simple SQL — write a join, count rows per group.
• DBMS basics — primary key vs foreign key, what is normalization.

HR & Culture Fit — standard set

Day-of checklist

• Resume — 2 printed copies. Carry a small notepad + pen.
• Carry college ID / government ID.
• Revise your projects the night before; be ready to talk about any line of code in them.
• Dress neatly; reach 30 min early.
• Sleep 7+ hours — the written test rewards a fresh brain.