42 NoSQL Database Interview Questions and Answers (2026)

// Example document in a 'products' collection
{
  _id: ObjectId("507f1f77bcf86cd799439011"),
  name: "Wireless Keyboard",
  brand: "Logitech",
  price: 79.99,
  tags: ["electronics", "peripherals", "wireless"],
  specs: {
    weight: "450g",
    connectivity: "Bluetooth 5.0",
    batteryLife: "24 months"
  },
  variants: [
    { color: "black", sku: "MK-BLK-US" },
    { color: "white", sku: "MK-WHT-US" }
  ],
  inStock: true,
  createdAt: ISODate("2026-03-15T10:30:00Z")
}

// INSERT
// Insert one document
db.users.insertOne({
  name: "Alice Chen",
  email: "alice@example.com",
  age: 28,
  roles: ["user", "editor"]
});

// Insert many documents
db.users.insertMany([
  { name: "Bob Smith", email: "bob@example.com", age: 34 },
  { name: "Carol Lee",  email: "carol@example.com", age: 25 }
]);

// READ
// Find all documents
db.users.find({});

// Find with filter, projection (include only specific fields)
db.users.find(
  { age: { $gte: 25 } },          // filter: age >= 25
  { name: 1, email: 1, _id: 0 }   // projection: include name, email; exclude _id
);

// Find one document
db.users.findOne({ email: "alice@example.com" });

// UPDATE
// Update one document
db.users.updateOne(
  { email: "alice@example.com" },                       // filter
  { $set: { age: 29 }, $addToSet: { roles: "admin" } }  // update operators
);

// Update many
db.users.updateMany(
  { age: { $lt: 18 } },
  { $set: { status: "minor" } }
);

// Upsert: insert if not found, update if found
db.users.updateOne(
  { email: "new@example.com" },
  { $set: { name: "New User", age: 22 } },
  { upsert: true }
);

// DELETE
db.users.deleteOne({ email: "bob@example.com" });
db.users.deleteMany({ status: "inactive", lastLogin: { $lt: new Date("2024-01-01") } });

db.orders.createIndex({ userId: 1 });   // ascending
db.orders.createIndex({ createdAt: -1 }); // descending (for sort queries)

db.orders.createIndex({ userId: 1, status: 1, createdAt: -1 });
// Supports queries on: userId | userId+status | userId+status+createdAt

db.users.createIndex({ email: 1 }, { unique: true });

db.users.createIndex({ phoneNumber: 1 }, { sparse: true });

db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 86400 });
// Documents are deleted 24 hours after their createdAt timestamp

db.articles.createIndex({ title: "text", body: "text" });
db.articles.find({ $text: { $search: "mongodb performance" } });

db.locations.createIndex({ coordinates: "2dsphere" });
db.locations.find({
  coordinates: {
    $near: { $geometry: { type: "Point", coordinates: [-73.9857, 40.7484] },
             $maxDistance: 1000 }  // within 1km
  }
});

db.orders.find({ userId: "abc123" }).explain("executionStats");
// Look for: IXSCAN (good) vs COLLSCAN (bad, full collection scan)

db.orders.aggregate([

  // $match: filter documents (like WHERE in SQL), put early to reduce work
  { $match: {
    status: "completed",
    createdAt: { $gte: ISODate("2026-01-01") }
  }},

  // $lookup: left join with another collection
  { $lookup: {
    from: "users",
    localField: "userId",
    foreignField: "_id",
    as: "user"
  }},

  // $unwind: deconstruct an array field into individual documents
  { $unwind: "$user" },

  // $group: aggregate documents (like GROUP BY in SQL)
  { $group: {
    _id: "$user.country",               // group by country
    totalRevenue: { $sum: "$total" },   // sum order totals
    orderCount:   { $sum: 1 },          // count orders
    avgOrderValue: { $avg: "$total" }   // average order value
  }},

  // $addFields / $project: add or reshape fields
  { $addFields: {
    revenuePerOrder: { $divide: ["$totalRevenue", "$orderCount"] }
  }},

  // $sort: sort results
  { $sort: { totalRevenue: -1 } },

  // $limit: limit output count
  { $limit: 10 },

  // $skip: skip N results (for pagination)
  // { $skip: 20 },

  // $out: write results to a new collection
  // { $out: "country_revenue_report" }
]);

// User document with embedded addresses
{
  _id: ObjectId("..."),
  name: "Alice",
  addresses: [
    { type: "home",    city: "New York", zip: "10001" },
    { type: "billing", city: "Boston",   zip: "02134" }
  ]
}

// Order references user by ID
{ _id: ObjectId("..."), userId: ObjectId("..."), total: 49.99 }

// Lookup user when needed
db.orders.aggregate([
  { $lookup: { from: "users", localField: "userId", foreignField: "_id", as: "user" } }
]);

// Enable sharding on a database
sh.enableSharding("ecommerce");

// Shard a collection by a hashed key (even distribution)
sh.shardCollection("ecommerce.orders", { userId: "hashed" });

// Shard by range (good for time-series: sequential writes to one shard, but
// allows efficient range queries by date)
sh.shardCollection("ecommerce.events", { timestamp: 1 });

// Connect to a replica set from application
const client = new MongoClient(
  "mongodb://node1:27017,node2:27017,node3:27017/mydb?replicaSet=rs0",
  { readPreference: "secondaryPreferred" } // reads go to secondaries when possible
);

// Read preferences:
// primary (default): always read from primary (strongly consistent)
// primaryPreferred: primary if available, else secondary
// secondary: always secondary (may be stale)
// secondaryPreferred: secondary if available, else primary
// nearest: lowest network latency

const session = client.startSession();

try {
  session.startTransaction({
    readConcern:  { level: "snapshot" },  // reads see a consistent snapshot
    writeConcern: { w: "majority" }       // write confirmed by majority of nodes
  });

  // Both operations succeed or both are rolled back
  await ordersCollection.insertOne(
    { userId, items, total: 149.99, status: "pending" },
    { session }
  );

  await inventoryCollection.updateMany(
    { _id: { $in: itemIds } },
    { $inc: { stock: -1 } },
    { session }
  );

  await session.commitTransaction();
  console.log("Transaction committed");

} catch (err) {
  await session.abortTransaction();
  console.error("Transaction aborted:", err.message);
} finally {
  await session.endSession();
}

// Automatically delete sessions 7 days after creation
db.sessions.createIndex(
  { createdAt: 1 },
  { expireAfterSeconds: 604800 }  // 7 days in seconds
);

// Session document
db.sessions.insertOne({
  sessionId: "abc123",
  userId: "user456",
  data: { cart: [], preferences: {} },
  createdAt: new Date()  // TTL index field
});

// You can also set a specific expiry time per document
db.notifications.createIndex(
  { expiresAt: 1 },
  { expireAfterSeconds: 0 }  // document expires exactly at the date stored in expiresAt
);

db.notifications.insertOne({
  message: "Your trial expires soon",
  userId: "user789",
  expiresAt: new Date("2026-12-31T23:59:59Z")  // this specific document expires here
});

// Watch a collection for all changes
const changeStream = db.collection("orders").watch();

changeStream.on("change", (event) => {
  console.log("Change type:", event.operationType); // insert, update, delete, replace
  console.log("Document key:", event.documentKey._id);
  console.log("Full document:", event.fullDocument);  // only for insert by default
  console.log("Update description:", event.updateDescription); // for updates
});

// Filter to only watch for new completed orders
const pipeline = [
  { $match: {
    operationType: "update",
    "updateDescription.updatedFields.status": "completed"
  }}
];
const filteredStream = db.collection("orders").watch(pipeline, {
  fullDocument: "updateLookup"  // include full document on update events
});

// Resume a stream after reconnection using a resume token
// Every change event includes a _id (resume token)
const resumeToken = lastProcessedEvent._id;
const resumedStream = collection.watch([], { resumeAfter: resumeToken });

// Run explain with executionStats for real numbers
db.orders.find({ userId: "abc123", status: "pending" })
         .sort({ createdAt: -1 })
         .explain("executionStats");

// Key things to look for in the output:
// winningPlan.stage: "COLLSCAN" = bad (no index), "IXSCAN" = good (using index)
// executionStats.totalDocsExamined vs nReturned:
//   If examined is much greater than returned, the index is not selective enough
// executionStats.executionTimeMillis: how long the query took

// Fix a COLLSCAN by adding a compound index
db.orders.createIndex({ userId: 1, status: 1, createdAt: -1 });

// Use projection to return only needed fields
db.orders.find({ userId: "abc123" }, { _id: 1, total: 1, status: 1 });
// Returns only 3 fields instead of the entire document

// Enable profiler to log slow queries (over 100ms)
db.setProfilingLevel(1, { slowms: 100 });

// View profiled queries
db.system.profile.find().sort({ ts: -1 }).limit(10);

// $set: set field values
db.users.updateOne({ _id: id }, { $set: { name: "Updated Name", age: 30 } });

// $unset: remove a field
db.users.updateOne({ _id: id }, { $unset: { temporaryField: "" } });

// $inc: increment a numeric field
db.products.updateOne({ _id: id }, { $inc: { viewCount: 1, stock: -2 } });

// $push: append to an array
db.posts.updateOne({ _id: id }, { $push: { comments: { text: "Great post!", userId: "u1" } } });

// $addToSet: append to array only if value is not already present
db.users.updateOne({ _id: id }, { $addToSet: { tags: "verified" } });

// $pull: remove matching elements from array
db.users.updateOne({ _id: id }, { $pull: { tags: "spam" } });

// $pop: remove first (-1) or last (1) element of array
db.lists.updateOne({ _id: id }, { $pop: { items: 1 } });  // remove last

// $rename: rename a field
db.users.updateMany({}, { $rename: { "fullName": "name" } });

// $currentDate: set field to current date
db.orders.updateOne({ _id: id }, { $currentDate: { updatedAt: true } });

// $min / $max: update only if new value is lower/higher than current
db.scores.updateOne({ userId: id }, { $max: { highScore: 9500 } });
// Only updates if 9500 is greater than the current highScore

SET user:1001:name "Alice Chen"
GET user:1001:name
SET page:views 0
INCR page:views           # atomic increment, becomes 1
INCRBY page:views 10      # becomes 11
EXPIRE user:1001:name 3600   # expire in 1 hour

HSET user:1001 name "Alice" email "alice@example.com" age 28
HGET user:1001 email           # "alice@example.com"
HGETALL user:1001              # all fields and values
HINCRBY user:1001 loginCount 1 # increment a numeric hash field

RPUSH jobs:queue "job:1" "job:2" "job:3"  # push to right (tail)
LPOP jobs:queue                            # pop from left (head), FIFO queue
LRANGE timeline:user:1001 0 9             # get first 10 items
LLEN jobs:queue                           # list length

SADD article:1:tags "mongodb" "nosql" "database"
SMEMBERS article:1:tags
SISMEMBER article:1:tags "nosql"  # 1 (exists) or 0 (not exists)
SINTER user:1:follows user:2:follows  # mutual follows
SUNIONSTORE result:tags tag:A tag:B   # store union of two sets

ZADD leaderboard 9500 "alice" 8750 "bob" 9200 "carol"
ZRANK leaderboard "alice"     # 0 (top rank, sorted ascending)
ZREVRANK leaderboard "alice"  # 2 (sorted descending, rank in top-N terms)
ZRANGE leaderboard 0 2 REV WITHSCORES  # top 3 with scores
ZINCRBY leaderboard 250 "bob"           # add 250 to bob's score

SETBIT users:active:2026-06-08 1001 1  # user 1001 was active today
GETBIT users:active:2026-06-08 1001    # 1
BITCOUNT users:active:2026-06-08       # total active users today

PFADD page:visitors:today user1 user2 user3 user4
PFCOUNT page:visitors:today  # estimated unique visitors

XADD events:orders * userId 1001 total 49.99 status pending
XREAD COUNT 10 STREAMS events:orders 0

# redis.conf
save 900 1      # save if 1 change in 15 minutes
save 300 10     # save if 10 changes in 5 minutes
save 60 10000   # save if 10000 changes in 1 minute

# redis.conf
appendonly yes
appendfsync everysec    # recommended balance of safety and performance

# redis.conf
maxmemory 4gb
maxmemory-policy allkeys-lru  # recommended for general caching

# Publisher (in one Redis client)
PUBLISH notifications:user:1001 '{"type":"order_shipped","orderId":"ORD-789"}'

# Subscriber (in another Redis client)
SUBSCRIBE notifications:user:1001

# Subscribe to a pattern (all notification channels)
PSUBSCRIBE notifications:*

const subscriber = redis.duplicate(); // use a dedicated connection
await subscriber.subscribe("notifications:user:1001", (message) => {
  const event = JSON.parse(message);
  sendWebSocketNotification(event);
});

// Publisher (using a separate connection)
await publisher.publish("notifications:user:1001",
  JSON.stringify({ type: "order_shipped", orderId: "ORD-789" }));

// Without pipelining: N round trips (slow for large N)
for (const key of keys) {
  await redis.get(key);
}

// With pipelining: 1 round trip for all commands
const pipeline = redis.pipeline();
for (const key of keys) {
  pipeline.get(key);
}
const results = await pipeline.exec();
// results is an array of [error, value] for each command

# Sentinel configuration
sentinel monitor mymaster 127.0.0.1 6379 2  # monitor master, quorum 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000

# Create a 6-node cluster (3 primary, 3 replica)
redis-cli --cluster create \
  127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 \
  127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 \
  --cluster-replicas 1

# Cluster info
redis-cli -p 7000 cluster info
redis-cli -p 7000 cluster nodes

const lockKey = "lock:payment:order-789";
const lockValue = crypto.randomUUID(); // unique value per lock holder
const ttl = 30; // seconds

const acquired = await redis.set(lockKey, lockValue, "NX", "EX", ttl);

if (acquired === "OK") {
  try {
    await processPayment(orderId);
  } finally {
    // Release: only delete if we still own it (Lua for atomicity)
    const script = `
      if redis.call("GET", KEYS[1]) == ARGV[1] then
        return redis.call("DEL", KEYS[1])
      else
        return 0
      end
    `;
    await redis.eval(script, 1, lockKey, lockValue);
  }
} else {
  throw new Error("Could not acquire lock: another instance is processing");
}

async function isRateLimited(userId, limit = 100, windowSeconds = 60) {
  const key = `ratelimit:${userId}:${Math.floor(Date.now() / 1000 / windowSeconds)}`;

  const count = await redis.incr(key);

  if (count === 1) {
    // First request in this window: set expiry
    await redis.expire(key, windowSeconds * 2);
  }

  return count > limit;
}

// Usage in Express middleware
app.use(async (req, res, next) => {
  const userId = req.user?.id || req.ip;
  if (await isRateLimited(userId)) {
    return res.status(429).json({ error: "Too many requests" });
  }
  next();
});

async function isRateLimitedPrecise(userId, limit = 100, windowMs = 60000) {
  const now = Date.now();
  const windowStart = now - windowMs;
  const key = `ratelimit:precise:${userId}`;

  const pipeline = redis.pipeline();
  pipeline.zremrangebyscore(key, 0, windowStart);  // remove old entries
  pipeline.zadd(key, now, `${now}-${Math.random()}`); // add current request
  pipeline.zcard(key);                               // count requests in window
  pipeline.expire(key, Math.ceil(windowMs / 1000));  // auto-cleanup

  const results = await pipeline.exec();
  const requestCount = results[2][1];
  return requestCount > limit;
}

// Table: Orders
// Partition key: userId | Sort key: orderId (sorts by time if you use a ULID)

// Items in the same partition (same userId):
{ userId: "user-1001", orderId: "ORD-2026-001", total: 49.99,  status: "shipped" }
{ userId: "user-1001", orderId: "ORD-2026-002", total: 129.00, status: "pending" }
{ userId: "user-1001", orderId: "ORD-2026-003", total: 22.50,  status: "delivered" }

// Query: get all orders for user-1001 sorted by orderId
// KeyConditionExpression: userId = :uid
// This is a single-partition query: extremely fast

// Base table: UserOrders
// PK: userId | SK: orderId

// LSI: query by status within a user's orders
// Same PK: userId | SK: status
// Lets you query: all pending orders for user-1001

// GSI: query by status across ALL users
// New PK: status | SK: orderId
// Lets you query: all pending orders across the entire system

// QUERY (efficient): get orders for a specific user
const result = await dynamoDB.query({
  TableName: "Orders",
  KeyConditionExpression: "userId = :uid AND orderId BETWEEN :start AND :end",
  ExpressionAttributeValues: {
    ":uid":   { S: "user-1001" },
    ":start": { S: "ORD-2026-001" },
    ":end":   { S: "ORD-2026-999" },
  },
}).promise();

// SCAN (expensive, reads all items): use only when necessary
const result2 = await dynamoDB.scan({
  TableName: "Orders",
  FilterExpression: "total > :minTotal",
  ExpressionAttributeValues: { ":minTotal": { N: "100" } },
}).promise();
// FilterExpression runs AFTER reading all items, it does not reduce RCU cost

// Parallel scan with 4 segments
for (let segment = 0; segment < 4; segment++) {
  promises.push(dynamoDB.scan({
    TableName: "Orders",
    TotalSegments: 4,
    Segment: segment,
  }).promise());
}

// Eventually consistent (default)
const result = await dynamoDB.getItem({
  TableName: "Orders",
  Key: { userId: { S: "user-1001" }, orderId: { S: "ORD-001" } },
}).promise();

// Strongly consistent
const strongResult = await dynamoDB.getItem({
  TableName: "Orders",
  Key: { userId: { S: "user-1001" }, orderId: { S: "ORD-001" } },
  ConsistentRead: true, // double the RCU cost
}).promise();

// Instead of: { pk: "LEADERBOARD", score: 9500, userId: "alice" }
// Use:        { pk: "LEADERBOARD#3", score: 9500, userId: "alice" }
// Rotate the suffix 0-9 on writes; query all 10 suffixes and merge on reads

// Lambda trigger: processes stream records automatically
exports.handler = async (event) => {
  for (const record of event.Records) {
    const { eventName, dynamodb } = record;

    if (eventName === "INSERT") {
      const newItem = AWS.DynamoDB.Converter.unmarshall(dynamodb.NewImage);
      await sendWelcomeEmail(newItem.email);
    }

    if (eventName === "MODIFY") {
      const oldItem = AWS.DynamoDB.Converter.unmarshall(dynamodb.OldImage);
      const newItem = AWS.DynamoDB.Converter.unmarshall(dynamodb.NewImage);

      if (oldItem.status !== newItem.status && newItem.status === "shipped") {
        await sendShippingNotification(newItem);
      }
    }
  }
};

// Without DAX: standard DynamoDB client
const ddb = new AWS.DynamoDB.DocumentClient();

// With DAX: swap the client, same API
const dax = new AmazonDaxClient({ endpoints: ["dax-cluster.xxx.dax.amazonaws.com:8111"] });
const daxClient = new AWS.DynamoDB.DocumentClient({ service: dax });

// The rest of your code is identical
const result = await daxClient.get({
  TableName: "Products",
  Key: { productId: "prod-001" },
}).promise();

// Users
{ PK: "USER#1001",     SK: "METADATA",       name: "Alice", email: "alice@example.com" }

// User's orders
{ PK: "USER#1001",     SK: "ORDER#ORD-001",  total: 49.99,  status: "shipped" }
{ PK: "USER#1001",     SK: "ORDER#ORD-002",  total: 129.00, status: "pending" }

// Order's items
{ PK: "ORDER#ORD-001", SK: "ITEM#prod-1",    qty: 2, price: 24.99 }
{ PK: "ORDER#ORD-001", SK: "ITEM#prod-2",    qty: 1, price: 0 }

// Products
{ PK: "PRODUCT#001",   SK: "METADATA",       name: "Widget", price: 24.99 }

// GSI for querying orders by status across all users:
// GSI PK: status | GSI SK: SK (orderId)

// One Query fetches a user and all their orders
await dynamoDB.query({
  TableName: "EcommerceTable",
  KeyConditionExpression: "PK = :pk AND begins_with(SK, :sk)",
  ExpressionAttributeValues: {
    ":pk": { S: "USER#1001" },
    ":sk": { S: "ORDER#" },
  },
}).promise();
// Returns: all ORDER# items for USER#1001

// Transfer credits between users atomically
await dynamoDB.transactWrite({
  TransactItems: [
    {
      // Condition check: ensure sender has enough credits
      ConditionCheck: {
        TableName: "Wallets",
        Key: { userId: { S: "user-A" } },
        ConditionExpression: "credits >= :amount",
        ExpressionAttributeValues: { ":amount": { N: "100" } },
      },
    },
    {
      // Deduct from sender
      Update: {
        TableName: "Wallets",
        Key: { userId: { S: "user-A" } },
        UpdateExpression: "SET credits = credits - :amount",
        ExpressionAttributeValues: { ":amount": { N: "100" } },
      },
    },
    {
      // Add to receiver
      Update: {
        TableName: "Wallets",
        Key: { userId: { S: "user-B" } },
        UpdateExpression: "SET credits = credits + :amount",
        ExpressionAttributeValues: { ":amount": { N: "100" } },
      },
    },
    {
      // Record the transfer
      Put: {
        TableName: "TransferLog",
        Item: {
          transferId: { S: "TXN-001" },
          from: { S: "user-A" },
          to: { S: "user-B" },
          amount: { N: "100" },
          timestamp: { S: new Date().toISOString() },
        },
      },
    },
  ],
}).promise();
// If ANY condition fails or write fails, nothing is committed