{"id":1281,"date":"2026-07-19T09:56:09","date_gmt":"2026-07-19T04:26:09","guid":{"rendered":"https:\/\/lastroundai.com\/blog\/?post_type=iq&#038;p=1281"},"modified":"2026-07-19T10:54:08","modified_gmt":"2026-07-19T05:24:08","slug":"hadoop","status":"publish","type":"iq","link":"https:\/\/lastroundai.com\/interview-questions\/hadoop","title":{"rendered":"Hadoop Interview Questions (2026): HDFS, MapReduce &#038; YARN Q&#038;A"},"content":{"rendered":"<p>In April 2008 a 910-node Yahoo cluster sorted a full terabyte of data in 209 seconds, the first time an open-source system had won the general-purpose terabyte sort benchmark and beating the prior record of 297 seconds (<a href=\"https:\/\/sortbenchmark.org\/YahooHadoop.pdf\" target=\"_blank\" rel=\"noopener noreferrer\">Owen O&#8217;Malley, Yahoo!, TeraByte Sort on Apache Hadoop, 2008<\/a>). Seven months later Google&#8217;s own MapReduce implementation did the same job in 68 seconds. That gap is worth sitting with: Hadoop&#8217;s original pitch was never raw speed. It was that you could throw a rack of commodity machines at a dataset too big for one box and get a correct answer back reliably, even though individual disks and nodes fail constantly at that scale.<\/p>\n<p>Here&#8217;s an opinion I&#8217;ll defend even though it&#8217;ll annoy some prep guides: most 2026 study material spends too long on HDFS trivia, recite the block size, recite the replication factor, and not nearly enough on the part that explains why real Hadoop clusters actually go down. That part is the NameNode&#8217;s relationship to memory. A NameNode that runs out of heap because an upstream job dumped four million tiny files into one directory takes the entire cluster&#8217;s metadata layer with it. Almost nobody asks about that in a five-minute definitional round, but it&#8217;s the failure mode that pages someone at 2am, not &#8220;what&#8217;s the default block size.&#8221;<\/p>\n<p>This page covers Hadoop interview questions across nine areas: what the Hadoop ecosystem actually includes beyond HDFS and MapReduce, HDFS&#8217;s NameNode, DataNode, and Secondary NameNode roles, blocks and replication, the MapReduce map-shuffle-reduce pipeline plus combiners and partitioners, YARN&#8217;s ResourceManager, NodeManager, and ApplicationMaster split, what changed across Hadoop 1, 2, and 3, Hive and Pig, the small-files problem, and how Hadoop actually relates to Spark rather than competing head to head with it. Code examples use plain Java for the MapReduce API, HiveQL for the SQL layer, and bash for the CLI commands an actual Hadoop admin types during an incident.<\/p>\n<div class=\"iq-stats not-prose\"><div class=\"iq-stat\"><span class=\"iq-stat__value\">52<\/span><span class=\"iq-stat__label\">Questions<\/span><\/div><div class=\"iq-stat\"><span class=\"iq-stat__value\">HDFS, MapReduce &amp; YARN<\/span><span class=\"iq-stat__label\">Core Topic<\/span><\/div><div class=\"iq-stat\"><span class=\"iq-stat__value\">Java, HiveQL &amp; CLI<\/span><span class=\"iq-stat__label\">Format<\/span><\/div><div class=\"iq-stat\"><span class=\"iq-stat__value\">3<\/span><span class=\"iq-stat__label\">Default Replication<\/span><\/div><\/div>\n<h2>Hadoop overview: what&#8217;s actually in &#8220;the ecosystem&#8221;<\/h2>\n<p>Every loop opens here, even for a candidate with five years of Hadoop on their resume. It&#8217;s a warm-up, but a vague answer signals you&#8217;ve only ever run someone else&#8217;s cluster and never read what&#8217;s underneath it.<\/p>\n<div class=\"iq-dsec iq-dsec--easy\"><div class=\"iq-dsec__row\"><h2 class=\"iq-dsec__h\" id=\"easy\"><span class=\"iq-dsec__dot\" aria-hidden=\"true\"><\/span>Easy questions<\/h2><span class=\"iq-dsec__n\">15<\/span><\/div><div class=\"iq-dsec__bar\" aria-hidden=\"true\"><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What is Hadoop, and what does &#039;the Hadoop ecosystem&#039; actually refer to?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Fundamentals<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Core Hadoop is three things working together: HDFS for distributed storage, YARN for cluster resource management, and MapReduce as one processing engine that runs on top of YARN, plus Hadoop Common, the shared libraries and utilities the other three depend on.<\/p>\n<p>&#8220;The ecosystem&#8221; is everything built around that core: Hive and Pig for query and scripting, HBase for random-access reads on top of HDFS, Sqoop for moving data between Hadoop and relational databases, Oozie for workflow scheduling, and ZooKeeper for the coordination that HDFS HA and several other pieces rely on. Spark is technically part of this ecosystem too, it&#8217;s just not part of core Hadoop, since it can run on YARN and read HDFS without needing MapReduce at all.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What do the NameNode and DataNode each actually do?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">HDFS<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>The NameNode is the master: it holds the entire filesystem namespace and the mapping of files to blocks in memory for speed, and it never stores actual file data itself. DataNodes are the workers: they store the real blocks on local disk, serve read and write requests directly to clients, and handle block creation, deletion, and replication only when the NameNode instructs them to.<\/p>\n<p>Clients talk to the NameNode first to figure out which DataNodes hold the blocks they need, then read or write directly to those DataNodes, the NameNode never sits in the actual data path once it&#8217;s handed out that information.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What&#039;s the default HDFS block size, and why does HDFS use such large blocks compared to a regular filesystem&#039;s 4KB pages?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Blocks<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>128MB by default in Hadoop 2.x and 3.x, up from 64MB in Hadoop 1.x, configurable through <code>dfs.blocksize<\/code>. HDFS was designed for streaming reads over large files, not random access to lots of small ones, so keeping blocks large minimizes the ratio of seek time to transfer time and keeps the NameNode&#8217;s per-block metadata overhead manageable, since every block is an object the NameNode has to track in memory.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">Walk through the three phases of a MapReduce job.<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">MapReduce<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>The map phase runs a user function over each input split and emits key-value pairs. The shuffle-and-sort phase, which runs entirely inside the framework, partitions every mapper&#8217;s output by key, sorts each partition, and transfers the right partition to the right reducer across the network. The reduce phase then runs a user function over all the values sharing a key and produces the final output.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What&#039;s the actual difference between Hive and Pig?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Hive &amp; Pig<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Hive gives you HiveQL, a declarative, SQL-like language, backed by a metastore that tracks table schemas and lets you query data sitting in HDFS as if it were a database table, schema-on-read rather than schema-on-write like a traditional RDBMS. Pig gives you Pig Latin, a procedural data-flow language where you write out each transformation step in sequence, load, filter, join, group, rather than describing the end result and letting an optimizer figure out the steps.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What is HDFS, and how is it fundamentally different from the filesystem on your laptop?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">HDFS Basics<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>HDFS is a distributed, block-based filesystem built to store very large files across many commodity machines and stream them for batch processing, not to act as a general-purpose POSIX filesystem. Your laptop&#8217;s filesystem (ext4, APFS, NTFS) manages a single physical disk and optimizes for low-latency random access, in-place edits, and full POSIX permission semantics. HDFS gives up almost all of that. Files get broken into large blocks (128MB or 256MB by default), each block is replicated three times across different machines, and the whole system is tuned for write-once, read-many, sequential scans rather than small random reads and writes.<\/p>\n<p>The other big difference is where metadata lives. On your laptop, metadata is scattered across the filesystem&#8217;s own on-disk structures. In HDFS, all file, directory, and block-location metadata lives in the memory of one process, the NameNode, while the actual data blocks sit on a separate fleet of DataNodes. That split is what lets HDFS scale to petabytes, but it also means the NameNode&#8217;s heap is a hard ceiling on how many files the cluster can hold, since it needs roughly 150 bytes of memory per file and block object no matter how big or small the underlying file is.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What is rack awareness in Hadoop, and why does the platform bother tracking which rack a node sits in?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Rack Awareness<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>A rack is a physical grouping of machines sharing a network switch and often power, so nodes on the same rack talk to each other fast and cheap, while traffic between racks crosses a slower, shared uplink. Rack awareness means Hadoop is configured, usually through a topology script, to know which physical rack each DataNode lives on.<\/p>\n<p>HDFS uses that information for two things. First, block placement: the default policy puts one replica on the writer&#8217;s local node, a second replica on a different rack entirely, and the third on the same rack as the second but a different machine. That spreads risk across whole-rack failures, like a switch or power circuit going down, while keeping two of three replicas close together to keep replication traffic cheap. Second, the scheduler prefers rack-local task placement when node-local placement isn&#8217;t available, since a rack-local read is far cheaper than a cross-rack one.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What is an InputSplit, and how does it relate to an HDFS block?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Input Splits<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>An InputSplit is the logical unit of input handed to a single Map task, and it&#8217;s a different concept from a physical HDFS block even though the two usually line up closely. A block is a fixed, physical chunk of data on disk, defined purely by size. An InputSplit is a logical reference, a file path plus a byte offset and length, computed by the InputFormat when the job is planned.<\/p>\n<p>For most text-based formats Hadoop tries to make splits match blocks, since a Map task assigned a split that lines up with a block can run on or near the DataNode holding it and avoid a network read. But splits don&#8217;t have to respect block boundaries. If a record straddles a block edge, the RecordReader for that split reaches across into the next block to finish the record, and the following split knows to skip that partial first line since the previous split already consumed it. This is also why huge counts of tiny files are wasteful: every file gets at least one split regardless of size, so a million 10KB files means a million Map tasks dominated entirely by startup overhead rather than real work.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What does the JobHistoryServer do, and why would you check it after a MapReduce job finishes?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Job History<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>The JobHistoryServer is a separate daemon that archives details of completed jobs after the ApplicationMaster that ran them has exited and YARN has reclaimed its resources. Without it, once a job finishes and its AM shuts down, all the counters, task timing, and log locations for that job would disappear the moment YARN cleans up.<\/p>\n<p>You&#8217;d check it any time you need a post-mortem on a job that already finished, which in practice is most debugging sessions, since by the time someone reports &#8220;yesterday&#8217;s job was slow,&#8221; the AM is long gone. It shows per-task start and finish times so you can spot stragglers, bytes read and written per task, counters like spilled records, and links to aggregated logs if log aggregation is enabled. It&#8217;s usually the first stop before SSHing into a NodeManager to dig through raw logs by hand.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What&#039;s the practical difference between &#039;hadoop fs -copyFromLocal&#039; and &#039;hadoop fs -put&#039;?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">HDFS CLI<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Functionally, for the common case, they do the same thing: copy a file from the local disk into HDFS. -put is the more general command and can also read from HDFS, another supported filesystem, or standard input using a dash, whereas -copyFromLocal is restricted specifically to a local source.<\/p>\n<p>Because -copyFromLocal enforces a local-only source, it&#8217;s a slightly safer choice in scripts where you want to guarantee you&#8217;re not accidentally re-copying a path that&#8217;s already inside HDFS or some other configured filesystem. In practice most engineers use -put out of habit since it&#8217;s shorter and the stdin trick, piping a local command&#8217;s output straight into HDFS, is handy. There&#8217;s no performance difference between them; they call the same underlying copy logic.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">In plain terms, what are the fsimage and edit log files, and how do they work together?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">NameNode Metadata<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>fsimage is a full, point-in-time snapshot of the HDFS namespace: every file, directory, permission, and block mapping. The edit log is an append-only journal of every namespace-changing operation, create, delete, rename, permission change, that has happened since the last fsimage was written.<\/p>\n<p>The split exists because keeping fsimage current on every write would mean serializing a huge in-memory structure to disk constantly, far too slow. Instead the NameNode appends a small record to the edit log for each change, which is fast, and periodically merges the log into a new fsimage during a background checkpoint, historically done by the Secondary NameNode, now typically the Standby NameNode in an HA setup. On a cold restart, the NameNode loads the last fsimage and replays every edit since that checkpoint to rebuild current state, which is why a NameNode with a huge, un-checkpointed edit log takes a long time to come back up.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What&#039;s the difference between a managed table and an external table in Hive?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Hive Tables<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>A managed (internal) table is one where Hive owns the data&#8217;s lifecycle: the data lives in Hive&#8217;s warehouse directory, and dropping the table deletes both the metadata and the underlying files. An external table just points Hive&#8217;s metastore at a location you specify, and dropping it only removes the metadata entry; the files stay untouched.<\/p>\n<p>External tables are the safer default for anything other systems or teams also touch, like raw landing-zone data an ingestion pipeline writes and several downstream jobs read, since a mistaken drop shouldn&#8217;t be able to wipe out data other people depend on. Managed tables make more sense for tables Hive fully controls end to end, where cleaning up on drop is actually convenient. The other practical difference is at creation time: external tables require a LOCATION, and running CREATE EXTERNAL TABLE over an existing directory just registers the schema without moving any data, which is exactly the workflow for onboarding data someone already dropped into HDFS.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">Name a few common Hadoop file formats and when you&#039;d pick each one.<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">File Formats<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Plain text (CSV, JSON, TSV) is easiest to work with and human-readable, but it&#8217;s the least efficient: no compression by default, no schema enforcement, and every consumer parses it fresh. SequenceFile is Hadoop&#8217;s own binary key-value format, splittable and compressible, and was the default choice before better columnar formats existed, though there&#8217;s little new adoption of it now.<\/p>\n<p>Avro is row-based binary with the schema stored alongside the data, which makes it solid for data moving between systems or evolving over time, since it handles adding or removing fields cleanly. Parquet and ORC are both columnar, storing all values of a column together rather than row by row, which is a big win for analytical queries touching only a handful of columns out of a wide table, and both support predicate pushdown and strong compression. Parquet tends to be the default in the Spark ecosystem, ORC in the Hive ecosystem, and choosing between them usually comes down to which query engine you&#8217;re optimizing for rather than any dramatic technical gap.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What is speculative execution in MapReduce?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Speculative Execution<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Speculative execution is a scheduling feature where, if one task is running noticeably slower than its siblings doing equivalent work, the framework launches a duplicate copy of that same task on a different node, and whichever copy finishes first wins while the other gets killed. It&#8217;s a blunt fix for the reality that in a large cluster some fraction of tasks will always be running on a node that&#8217;s slow for reasons unrelated to the actual work, a bad disk, memory pressure from another job, flaky hardware, and there&#8217;s no point waiting on it if a fresh attempt elsewhere would likely finish first.<\/p>\n<p>It&#8217;s controlled by config, mapreduce.map.speculative and mapreduce.reduce.speculative, both true by default in most distros, and it only kicks in once a task has been running long enough relative to the average progress of similar tasks to look genuinely behind rather than just handling more data. It&#8217;s worth turning off for jobs with non-idempotent side effects, like a reducer writing directly to an external database rather than through HDFS&#8217;s atomic commit path, since two speculative attempts both completing can cause duplicate or conflicting writes.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What does &#039;hadoop fs -du&#039; show you, and how is that different from &#039;-count&#039;?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">HDFS Disk Usage<\/span><span class=\"iq-badge iq-badge--easy\">Easy<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>&#8216;hadoop fs -du&#8217; reports the actual disk space consumed by files at a given path, broken down per file or summarized with -s, generally showing raw file size rather than the replicated footprint, so you have to factor in the replication factor separately if you want true disk consumption. &#8216;hadoop fs -count&#8217; reports on structure rather than size: the number of directories, number of files, and total size under a path.<\/p>\n<p>In practice you&#8217;d run -count when auditing whether a directory has an unreasonable file count relative to its total size, a huge file count paired with a small total size is the red flag for the small-files problem, and you&#8217;d run -du when you actually care how much storage a dataset is consuming, say before deciding whether to compress it or delete an old partition to reclaim space.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-dsec iq-dsec--medium\"><div class=\"iq-dsec__row\"><h2 class=\"iq-dsec__h\" id=\"medium\"><span class=\"iq-dsec__dot\" aria-hidden=\"true\"><\/span>Medium questions<\/h2><span class=\"iq-dsec__n\">25<\/span><\/div><div class=\"iq-dsec__bar\" aria-hidden=\"true\"><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">Where did Hadoop actually come from, and what problem was it solving before anyone cared about big data as a buzzword?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">History<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Doug Cutting and Mike Cafarella built it starting in 2005 as the storage and processing layer for Nutch, an open-source web crawler, after reading Google&#8217;s GFS and MapReduce papers. The problem wasn&#8217;t abstract: Nutch needed to index a meaningful slice of the web on hardware nobody could afford to keep perfectly reliable, so the design assumed failure was routine, not exceptional, and built replication and re-execution in from day one instead of bolting it on later.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">Why is a single NameNode considered a single point of failure, and how does Hadoop 2+ actually fix that?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">High Availability<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Before Hadoop 2, there was exactly one NameNode holding the entire namespace in memory, and losing it meant the cluster&#8217;s metadata layer was gone until someone manually restored it from disk on a new machine, which could take a long time on a big namespace.<\/p>\n<p>HDFS High Availability with the Quorum Journal Manager fixes this by running an Active NameNode and one or more Standby NameNodes that share edit logs through a set of JournalNodes. The Active durably writes every namespace change to a majority of JournalNodes, and each Standby continuously reads those edits to stay current. A ZKFailoverController on each NameNode monitors health and coordinates automatic failover through ZooKeeper, so a Standby can take over within seconds instead of requiring someone to page in and restore metadata by hand (<a href=\"https:\/\/hadoop.apache.org\/docs\/stable\/hadoop-project-dist\/hadoop-hdfs\/HDFSHighAvailabilityWithQJM.html\" target=\"_blank\" rel=\"noopener noreferrer\">Apache Hadoop, HDFS High Availability with QJM<\/a>).<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What does the Secondary NameNode actually do, and why is &#039;it&#039;s a backup NameNode&#039; the wrong answer?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">HDFS<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>It performs checkpointing, not failover. The NameNode keeps its namespace as an fsimage on disk plus an edit log of every change since the last checkpoint. Left alone, that edit log grows without bound and replaying a huge one on restart gets slower every day. The Secondary NameNode periodically pulls the fsimage and edit log, merges them into a fresh fsimage, and hands that back, by default every hour or every million transactions, whichever comes first.<\/p>\n<p>It holds no live copy of the namespace ready to serve traffic, so if the primary NameNode dies, the Secondary can&#8217;t just start answering client requests. In an HA cluster you don&#8217;t run one at all, the official docs are blunt about it: running a Secondary NameNode alongside HA &#8220;would be an error,&#8221; because the Standby NameNode already does the checkpointing job itself (<a href=\"https:\/\/hadoop.apache.org\/docs\/stable\/hadoop-project-dist\/hadoop-hdfs\/HDFSHighAvailabilityWithQJM.html\" target=\"_blank\" rel=\"noopener noreferrer\">Apache Hadoop, HDFS High Availability with QJM<\/a>). Naming it &#8220;Secondary&#8221; instead of something like &#8220;Checkpoint Node&#8221; is arguably the single most confusing decision in Hadoop&#8217;s entire vocabulary.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What&#039;s the default replication factor, and how does HDFS decide where to place the copies?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Replication<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p><code>dfs.replication<\/code> defaults to 3. The default rack-aware placement policy puts the first replica on the writer&#8217;s local node (or a random node if the write comes from outside the cluster), the second replica on a node in a different rack, and the third on a different node in that same second rack (<a href=\"https:\/\/hadoop.apache.org\/docs\/stable\/hadoop-project-dist\/hadoop-hdfs\/HdfsDesign.html\" target=\"_blank\" rel=\"noopener noreferrer\">Apache Hadoop, HDFS Architecture<\/a>).<\/p>\n<p>That split is deliberate: spreading across two racks means losing an entire rack, a switch failure, a power event, still leaves a live copy, while keeping two of the three replicas on the same rack avoids paying full cross-rack network cost for every single write.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What is a combiner, and why isn&#039;t it just a reducer that happens to run early?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Combiner<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>A combiner runs on a mapper&#8217;s own output, locally, before the shuffle sends anything across the network, functioning as a mini-reduce step that cuts down how much data has to travel. It usually shares code with the actual reducer, but the framework treats it as optional: it might run zero times, once, or multiple times per mapper, and Hadoop makes no promise about which.<\/p>\n<p>That&#8217;s why a combiner has to be safe to apply partially and repeatedly, mathematically it needs to be associative and commutative. Sum, count, and max are fine. Average is not, and this is the single most common combiner mistake candidates walk into.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What does the partitioner do, and when would you write a custom one instead of using the default?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Partitioner<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>The partitioner decides which reducer each key&#8217;s data goes to. The default, HashPartitioner, does <code>key.hashCode() % numReducers<\/code>, which spreads keys evenly across reducers as long as the keys themselves are reasonably well distributed.<\/p>\n<p>Write a custom partitioner when they aren&#8217;t, a handful of keys account for most of the data and the default hash happens to pile several of the heaviest ones onto the same reducer, leaving that reducer running long after the others finished. This is the exact same skew problem Spark deals with on the join side, just showing up on the reduce side of MapReduce instead.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What problem did YARN actually solve, and why wasn&#039;t the old JobTracker good enough?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">YARN<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>In Hadoop 1, a single JobTracker did two jobs at once: managing cluster resources and scheduling and monitoring every MapReduce task. That coupling became a real bottleneck as clusters grew past a few thousand nodes, the JobTracker was both a scalability ceiling and, like the original NameNode, a single point of failure with no HA story of its own.<\/p>\n<p>YARN split those two responsibilities apart. Cluster-wide resource management moved into the ResourceManager, and per-job scheduling moved into a per-application ApplicationMaster. That split also had a side effect nobody fully appreciated at the time: once resource management didn&#8217;t assume every job was a MapReduce job, Spark, Tez, and other engines could run on the same cluster and share the same pool of machines instead of each needing its own dedicated cluster.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What do the ResourceManager, NodeManager, and ApplicationMaster each own?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">YARN<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>The ResourceManager is the cluster-level master, containing a pure Scheduler that allocates resources with no visibility into whether a task succeeded or failed, plus an ApplicationsManager that accepts new job submissions and negotiates the very first container for each job&#8217;s ApplicationMaster. The NodeManager is a per-machine agent that manages containers running on that one node and reports resource usage back to the ResourceManager. The ApplicationMaster is per-job, one instance gets launched for every running application, and it negotiates additional containers from the ResourceManager&#8217;s Scheduler, then works directly with NodeManagers to launch and monitor the actual tasks inside those containers.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What changed going from Hadoop 1 to Hadoop 2?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Versions<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Three things, and they&#8217;re the ones interviewers actually expect: YARN replaced the JobTracker\/TaskTracker model, decoupling resource management from job scheduling; NameNode High Availability arrived, using the Quorum Journal Manager to remove the old single point of failure; and HDFS Federation let multiple independent NameNodes each own their own namespace while sharing one common pool of DataNodes, so metadata capacity could scale by adding NameNodes instead of being capped by one machine&#8217;s memory. The default block size also moved from 64MB to 128MB in this generation.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What changed going from Hadoop 2 to Hadoop 3, and does most of it actually matter day to day?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Versions<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>The headline feature is erasure coding: instead of three full copies of every block, which is 200% storage overhead on top of the original data, HDFS can use a Reed-Solomon-style encoding that gets the same fault tolerance down to roughly 50% overhead for data that isn&#8217;t accessed often enough to justify paying for three full copies. Hadoop 3 also allows more than one Standby NameNode in an HA quorum (Hadoop 2 only supported exactly one), added YARN Timeline Service v2 for more scalable job history storage, added support for running application code inside Docker containers on YARN, and bumped the minimum supported Java version to 8.<\/p>\n<p>Honestly, most teams I&#8217;ve seen reference in mock interviews only ever mention erasure coding by name. The rest of the Hadoop 3 feature list is real but doesn&#8217;t come up much outside a platform-engineer-specific loop.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">Does Hive still run everything as MapReduce jobs under the hood in 2026?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Hive &amp; Pig<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Not by default on any cluster I&#8217;d expect to see in a current interview. <code>hive.execution.engine<\/code> is configurable, and most teams that still run Hive point it at Tez or Spark instead of raw MapReduce, since both avoid writing every intermediate stage&#8217;s output to disk the way classic MapReduce does. Pig has followed the same path, it can target Tez instead of MapReduce too, though Pig itself has fallen out of favor generally as Spark SQL and Hive have absorbed most of what teams used to reach for it to do.<\/p>\n<p><div class=\"iq-code not-prose\"><div class=\"iq-code__bar\"><span class=\"iq-code__lang\">sql<\/span><button class=\"iq-code__copy\" type=\"button\">Copy<\/button><\/div><pre><code class=\"language-sql\">\n\nCREATE TABLE page_views (\n\n  user_id STRING,\n\n  url STRING,\n\n  view_time BIGINT\n\n)\n\nPARTITIONED BY (dt STRING)\n\nSTORED AS PARQUET;\nSELECT url, COUNT(*) AS views\n\nFROM page_views\n\nWHERE dt = \u20182026-07-01\u2019\n\nGROUP BY url\n\nORDER BY views DESC\n\nLIMIT 10;\n<\/code><\/pre><\/div><br \/>\n<\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">Why is having millions of small files in HDFS actually a problem if the total data volume is small?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Small Files<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Every file, directory, and block is an object the NameNode has to track in memory, commonly estimated at around 150 bytes of heap per object. A million tiny files well under the 128MB block size means a million metadata objects for a dataset that might only add up to a few gigabytes, and that memory pressure on the NameNode doesn&#8217;t care how little actual data is behind it.<\/p>\n<p>Processing takes a hit too. MapReduce and Spark both default to roughly one task per input split, so a job reading a million small files spins up far more tasks than the actual data volume justifies, and most of each task&#8217;s time goes to overhead instead of real work.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">You&#039;ve inherited a cluster with a directory full of millions of small files. What are your actual options?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Small Files<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Consolidate first, upstream if you can: fix whatever&#8217;s producing the small files, a streaming job flushing too often, an overly aggressive number of reducers, so new small files stop accumulating. For what&#8217;s already there, Hadoop Archives (HAR files) pack many small files into fewer larger ones without changing how they look to a client, CombineFileInputFormat lets a single map task read multiple small files instead of one task per file, and switching the actual storage format to something like SequenceFile, Avro, or Parquet bundles many logical records into far fewer physical files going forward.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">Is &#039;Hadoop vs Spark&#039; even the right framing for this question?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Hadoop vs Spark<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Not really. Spark commonly runs as a YARN application and reads and writes data through HDFS, so a lot of &#8220;Hadoop vs Spark&#8221; answers are actually comparing MapReduce against Spark while Hadoop&#8217;s storage and resource-management layers sit underneath both unchanged. If you want the deeper mechanics, shuffle behavior, lazy evaluation, the Catalyst optimizer, that&#8217;s covered on the <a href=\"\/interview-questions\/apache-spark\/\">Spark interview questions page<\/a>; this page sticks to how the two actually coexist on the same cluster.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">A NameNode restarts and the cluster is stuck in safe mode. What&#039;s actually happening, and how do you get it out?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Troubleshooting<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>On startup the NameNode loads its fsimage and edit log but doesn&#8217;t yet know which DataNodes are actually alive or which blocks they&#8217;re reporting, so it enters safe mode automatically and refuses write operations until DataNodes have reported in. By default it won&#8217;t leave safe mode until 99.9% of blocks have at least one confirmed replica somewhere on the cluster.<\/p>\n<p><div class=\"iq-code not-prose\"><div class=\"iq-code__bar\"><span class=\"iq-code__lang\">bash<\/span><button class=\"iq-code__copy\" type=\"button\">Copy<\/button><\/div><pre><code class=\"language-bash\">\n\nhdfs dfsadmin -safemode get\n\nhdfs dfsadmin -report\n\nhdfs fsck \/ -files -blocks | grep -i \u201cunder|missing\u201d\n<\/code><\/pre><\/div><\/p>\n<p>If it&#8217;s stuck well past the time DataNodes normally take to report in, run <code>fsck<\/code> to see whether blocks are actually missing rather than just slow to report. Forcing <code>hdfs dfsadmin -safemode leave<\/code> when real blocks are genuinely under-replicated just hides the problem instead of fixing it, and I&#8217;d only reach for that command once fsck confirms the cluster&#8217;s actually healthy and just being slow.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What is HDFS federation, and why would a large cluster actually need it?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">HDFS Federation<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>HDFS federation lets a cluster run multiple independent NameNodes, each owning a separate namespace, its own slice of the directory tree, but sharing the same pool of DataNodes for block storage. Before federation, every cluster had exactly one active namespace and one NameNode holding all metadata in memory, which capped the cluster&#8217;s total file count at whatever a single NameNode&#8217;s heap could hold, typically a few hundred million files before heap size and garbage collection pauses became unmanageable.<\/p>\n<p>Federation splits metadata across multiple NameNodes, so you might run one namespace for one business unit&#8217;s data and another for a different one, each independently scalable and independently restartable without affecting the other&#8217;s availability. DataNodes report block state to every NameNode they&#8217;re shared with through a block pool abstraction, so physical storage stays unified even though the namespace is split. The tradeoff is operational complexity: clients now need a way to know which namespace a given path belongs to, usually handled through ViewFs or mount tables, and you&#8217;re now running and failover-protecting multiple NameNode pairs instead of one.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What is the distributed cache in Hadoop, and when would you actually reach for it?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Distributed Cache<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>The distributed cache is a mechanism for shipping read-only auxiliary files, jars, lookup tables, configuration, small reference datasets, to every node that will run a task for your job, so each task has local access without you writing custom code to fetch it over the network at runtime. You register the files through -files, -archives, -libjars, or the DistributedCache API, and the framework copies them once to each NodeManager and makes them available in the task&#8217;s working directory.<\/p>\n<p>The classic use case is a broadcast join: a small lookup table, say a country-code to country-name mapping, paired with a huge fact table. Instead of an expensive shuffle join in the reduce phase, you push the small table into the distributed cache, load it into an in-memory hash map inside each Mapper&#8217;s setup() method, and do the join entirely on the map side with no shuffle at all. The main gotcha is that &#8220;small&#8221; really means small, a few hundred MB at most, since every task on every node ends up with its own local copy, and pushing something too large through the cache can saturate local disk and network during distribution instead of helping.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What happens during the sort-and-spill phase on the map side, and why does &#039;io.sort.mb&#039; matter for performance?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Map-Side Spill<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Map output isn&#8217;t written straight to disk as each key-value pair is emitted. It goes into an in-memory circular buffer, sized by mapreduce.task.io.sort.mb, 100MB by default, and once that buffer crosses a fill threshold, 80% by default, a background thread sorts the buffered records by partition and key and spills them to a local disk file while the Mapper keeps emitting new records into the rest of the buffer. If a Mapper produces more output than fits across multiple spill cycles, several spill files accumulate and then get merged into one final sorted, partitioned file before the shuffle phase copies it out to reducers.<\/p>\n<p>This matters for performance because a spill buffer too small relative to actual output volume causes many small spill files, and merging many small files costs real I\/O and CPU across repeated merge passes. The common symptom shows up in a job&#8217;s counters as a high ratio of spilled records to map output records, meaning data was written and re-read from local disk multiple times before shuffling even started. The fix is usually raising the sort buffer, trading task heap for buffer space, increasing the merge fan-in, or adding a combiner so there&#8217;s simply less data to spill in the first place.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What&#039;s the difference between Hadoop Streaming and writing a native Java MapReduce job?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Hadoop Streaming<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Hadoop Streaming lets you write your Mapper and Reducer as any executable that reads from stdin and writes to stdout, most commonly Python or a shell script, and Hadoop pipes records in and out as tab-separated text, treating everything up to the first tab as the key and the rest as the value. It&#8217;s genuinely useful when a team&#8217;s expertise or existing tooling is in Python and rewriting a two-line transformation as a full Java class feels like overkill.<\/p>\n<p>The cost is real, though. Every record gets serialized to text and deserialized on both sides of the pipe, measurably slower than staying inside the JVM with native Writable types, and you lose access to finer control, custom partitioners, custom InputFormats, direct distributed cache API access, fine-grained counters. For a quick, throwaway transformation over a modest dataset, Streaming is fine. For a job running daily over terabytes where performance actually matters, the process-per-task overhead and serialization tax usually push teams toward native Java, or more commonly today, off raw MapReduce entirely toward Spark or Hive.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What does setting the reducer count to zero actually do, and when is a map-only job the right call?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Map-Only Jobs<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Setting mapreduce.job.reduces to 0 tells the framework to skip the shuffle and reduce phase entirely; each Mapper writes its output straight into the job&#8217;s output directory in HDFS, with no sort, no partition, and no reduce step at all. This is the right call whenever the transformation is genuinely row-by-row or file-by-file and doesn&#8217;t require grouping records by key across the whole dataset: filtering bad records, reformatting each record independently, converting file formats, or enriching a record via a small lookup pulled through the distributed cache.<\/p>\n<p>The upside is significant, since you skip the most expensive part of a MapReduce job, the shuffle, with its network transfer, sort, and merge, so a map-only job over a large dataset can finish in a fraction of the time an equivalent job with a reduce phase would take. The catch is that output file count exactly matches input split count, since each Mapper writes its own output file independently, so thousands of small input splits become thousands of small output files unless you follow up with a compaction step.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What does &#039;hdfs fsck&#039; actually check, and what output from it should worry you?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">HDFS fsck<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>&#8216;hdfs fsck&#8217; walks the HDFS namespace and checks block health: it verifies that every file&#8217;s blocks have enough live replicas, flags blocks that are under-replicated, over-replicated, or in the worst case missing entirely with zero live replicas anywhere in the cluster, which is corruption. You&#8217;d typically run it against a specific path with flags like -files -blocks -locations for the full per-block replica breakdown, or at the root with a summary for overall cluster health.<\/p>\n<p>The output that actually worries you is anything under corrupt files or a nonzero missing-block count, since that means real data loss, not just a temporary replication deficit the NameNode&#8217;s replication monitor will fix on its own within minutes. Under-replicated blocks by themselves usually aren&#8217;t an emergency, that&#8217;s the normal state right after a DataNode goes down while the cluster re-replicates from remaining copies, but if that count stays flat or climbs instead of shrinking, it usually means the cluster lacks enough healthy DataNode capacity or rack diversity to satisfy the replication policy.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What role does ZooKeeper play in a Hadoop cluster?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">ZooKeeper Role<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>ZooKeeper is the coordination service Hadoop leans on for anything needing distributed consensus or leader election, and in a modern HA cluster it&#8217;s doing real, load-bearing work rather than sitting there as an optional add-on. The most direct example is NameNode HA itself: ZKFC processes run alongside the active and standby NameNodes, using ZooKeeper&#8217;s ephemeral znode mechanism to hold a lock representing &#8220;who is currently active.&#8221; If the active NameNode&#8217;s ZKFC loses its session, because the node died, hung, or got network-partitioned, the znode disappears, the standby&#8217;s ZKFC notices, acquires the lock, and triggers failover.<\/p>\n<p>Beyond NameNode HA, ZooKeeper is also what HBase relies on for region server coordination and tracking which server hosts the meta table, and YARN&#8217;s ResourceManager HA uses the same pattern for RM failover. It&#8217;s a small, quorum-based service, typically run with 3 or 5 nodes so it can tolerate a minority of failures and still keep a majority to agree on state, and losing the ZooKeeper quorum itself, not just one NameNode, is one of the genuinely dangerous failure modes in an HA cluster because it takes out the failover mechanism along with it.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What is Oozie, and how does workflow scheduling fit around a Hadoop pipeline?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Oozie Workflows<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Oozie is a workflow scheduler built specifically for Hadoop, letting you define multi-step pipelines, a Hive query followed by a Pig script followed by a Java MapReduce job followed by shipping the result somewhere, as a directed graph in XML, with each node an action and edges representing dependencies, including conditional branches on success or failure of a prior step.<\/p>\n<p>It fills a gap a plain cron job doesn&#8217;t: real dependency management (step three shouldn&#8217;t start until steps one and two both succeed), retry policies per action, and native Hadoop awareness, meaning it understands YARN application IDs and tracks a submitted job&#8217;s actual status rather than just checking whether a process exited. Oozie also has a separate Coordinator layer on top of workflows for time- or data-availability-based triggering, run this every day at 2am, or as soon as a particular HDFS path is ready. A lot of newer teams have moved to Airflow instead for its friendlier Python DAG definitions and nicer UI, but Oozie is still common in older, established Hadoop deployments and integrates a bit more tightly with Kerberos delegation tokens out of the box.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What&#039;s the difference between HDFS space quotas and name quotas, and why do teams enable both?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">HDFS Quotas<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>A name quota limits the number of file and directory entries allowed under a path, regardless of how big those files are, and it exists specifically to protect the NameNode&#8217;s heap from being exhausted by an unbounded number of small files. A space quota limits the actual bytes of storage consumable under a path, accounting for replication factor, so a 1GB quota with 3x replication really limits you to about 341MB of unique data, not 1GB.<\/p>\n<p>Teams enable both together because they protect against two different failure modes. Space quotas stop a team from filling shared cluster storage with an oversized dataset. Name quotas stop a subtler problem: a job gone wrong, like a bug writing one tiny output file per record instead of batching, that creates millions of small files while consuming very little actual disk space but does real damage to NameNode memory and RPC load, since every file object costs roughly 150 bytes of heap and every open, create, or list call is an RPC the single NameNode has to serve. Multi-tenant clusters set both per top-level directory so one team&#8217;s runaway job can&#8217;t degrade the cluster for everyone else.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">Why does Hive partitioning (and bucketing) actually help query performance, and what&#039;s the tradeoff if you over-partition?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Hive Partitioning<\/span><span class=\"iq-badge iq-badge--medium\">Medium<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Partitioning splits a table&#8217;s data into separate physical directories based on the value of one or more columns, most commonly something like date, so a query filtering on that column can skip entire directories it doesn&#8217;t need, a technique called partition pruning. Without partitioning, a query for yesterday&#8217;s data out of a five-year table has to scan the whole table row by row; with date partitioning it only touches yesterday&#8217;s directory.<\/p>\n<p>Bucketing is a finer-grained, complementary technique: within a partition, rows get hashed into a fixed number of files based on a column, which helps join performance since two tables bucketed the same way on the join key can be joined bucket-to-bucket without a full shuffle, and it gives more even file sizes than partitioning alone. The tradeoff with over-partitioning is real: partitioning on a high-cardinality column, or nesting too many partition columns, date plus hour plus customer_id, produces an explosion of tiny directories, each with its own small files, turning the small-files problem into a partitioning problem and slowing the Hive metastore itself, since every partition is a row in the metastore&#8217;s relational database and query planning has to enumerate them all.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-dsec iq-dsec--hard\"><div class=\"iq-dsec__row\"><h2 class=\"iq-dsec__h\" id=\"hard\"><span class=\"iq-dsec__dot\" aria-hidden=\"true\"><\/span>Hard questions<\/h2><span class=\"iq-dsec__n\">12<\/span><\/div><div class=\"iq-dsec__bar\" aria-hidden=\"true\"><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">A DataNode&#039;s disk dies silently. How does HDFS actually notice, and what happens next?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Fault Tolerance<\/span><span class=\"iq-badge iq-badge--hard\">Hard<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>DataNodes send a heartbeat to the NameNode every 3 seconds by default. If the NameNode hasn&#8217;t heard from a DataNode in roughly ten and a half minutes, the formula works out to twice the recheck interval plus ten heartbeat intervals, it marks that node dead and treats every block that lived only there as under-replicated.<\/p>\n<p>The NameNode then schedules re-replication of those blocks from their surviving copies onto other healthy DataNodes, automatically, no human involved. Running <code>hdfs fsck \/<\/code> after an incident like this is the standard way to confirm how many blocks were actually affected and whether re-replication finished cleanly instead of just trusting that it did.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">If you plug an average calculation straight into a combiner, what actually goes wrong?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Combiner<\/span><span class=\"iq-badge iq-badge--hard\">Hard<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Averaging partial averages doesn&#8217;t equal the true average unless every partial group happens to have the same count, which almost never holds in real data. A combiner that runs on an uneven split of a key&#8217;s values computes a local average, and reducing several of those local averages together produces a number close to the right answer but not equal to it, silently.<\/p>\n<p><div class=\"iq-code not-prose\"><div class=\"iq-code__bar\"><span class=\"iq-code__lang\">java<\/span><button class=\"iq-code__copy\" type=\"button\">Copy<\/button><\/div><pre><code class=\"language-java\">\n\n\/\/ WRONG: combiner computes an average directly\n\npublic void reduce(Text key, Iterable&lt;IntWritable&gt; values, Context ctx)\n\n    throws IOException, InterruptedException {\n\n  int sum = 0, count = 0;\n\n  for (IntWritable v : values) { sum += v.get(); count++; }\n\n  ctx.write(key, new DoubleWritable(sum \/ (double) count)); \/\/ wrong once combined\n\n}\n\/\/ FIX: combiner and reducer both emit sum+count; only the\n\n\/\/ final reducer divides\n\npublic void reduce(Text key, Iterable&lt;PairWritable&gt; values, Context ctx)\n\n    throws IOException, InterruptedException {\n\n  long sum = 0, count = 0;\n\n  for (PairWritable v : values) { sum += v.getSum(); count += v.getCount(); }\n\n  ctx.write(key, new DoubleWritable(sum \/ (double) count)); \/\/ correct\n\n}\n<\/code><\/pre><\/div><\/p>\n<p>The fix is to make the combiner emit a sum and a count as a pair instead of a finished average, and only compute the actual division in the final reducer, once every partial sum and count has genuinely been combined together.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">If Spark can run on a Hadoop cluster, does that mean Spark runs on Hadoop&#039;s MapReduce engine?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">YARN<\/span><span class=\"iq-badge iq-badge--hard\">Hard<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>No, and mixing this up is an easy way to lose points in an interview. Spark on a Hadoop cluster almost always means Spark running as a YARN application, with its own driver acting like an ApplicationMaster and its executors running inside YARN containers, reading and writing data through HDFS. MapReduce never enters the picture at all.<\/p>\n<p>This is worth internalizing separately from the rest of Hadoop: YARN is the resource manager, MapReduce is one processing engine among several that can use it, and HDFS is the storage layer underneath both. &#8220;Hadoop&#8221; as a marketing term bundles all three, but they&#8217;re genuinely separable pieces.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">Given that they coexist, what&#039;s the real reason Spark jobs usually finish faster than the equivalent MapReduce job?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Hadoop vs Spark<\/span><span class=\"iq-badge iq-badge--hard\">Hard<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Classic MapReduce writes intermediate output back to HDFS between every map and reduce stage, so a multi-stage pipeline pays for a disk round trip at every boundary. Spark represents the whole computation as a DAG and can keep data in memory across stages, spilling to disk only under real pressure, which matters most for iterative jobs that touch the same data repeatedly.<\/p>\n<p>I&#8217;d stop short of saying &#8220;Spark is just Hadoop with a cache,&#8221; though. When a Databricks team broke the sort benchmark in 2014, sorting 100TB in 23 minutes versus the standing Hadoop MapReduce record of 72 minutes, they did it entirely on disk without using Spark&#8217;s in-memory cache at all. A chunk of that speedup came from a better DAG scheduler and a more efficient shuffle implementation, not memory. Memory is a real advantage, it&#8217;s just not the whole story.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">One reducer in a job is taking forty minutes while every other reducer finished in two. What&#039;s your first move?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Troubleshooting<\/span><span class=\"iq-badge iq-badge--hard\">Hard<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Check the job counters for records-per-reducer first, this is almost always key skew: one key, sometimes a literal null or default value catching everything that didn&#8217;t match a real category, has far more values than the rest and the default HashPartitioner sent it all to a single reducer.<\/p>\n<p>Speculative execution, on by default, will launch a duplicate copy of a task that&#8217;s running much slower than its siblings and use whichever finishes first. That&#8217;s a reasonable safety net for a genuinely slow machine, but it&#8217;s a real hazard if a reducer&#8217;s code has non-idempotent side effects, writing to an external system, sending a notification, since a speculative duplicate can fire that same side effect twice. For skew specifically, the actual fix is a custom partitioner, or salting the skewed key so it spreads across several reducers instead of piling onto one, the same idea Spark interviews ask about on the join side.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What is erasure coding in Hadoop 3, and what&#039;s the real tradeoff against 3x replication?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Erasure Coding<\/span><span class=\"iq-badge iq-badge--hard\">Hard<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Standard HDFS replication stores three full copies of every block, so a 100MB block costs 300MB of raw disk, a 3x overhead, in exchange for simple, fast recovery, just copy one of the two remaining full replicas, and the ability to serve reads from any of three separate DataNodes. Erasure coding, introduced properly in Hadoop 3, instead splits a block into data cells and computes parity cells with an algorithm like Reed-Solomon, commonly configured as RS-6-3, six data cells plus three parity cells, so you can lose up to three of the nine cells and still reconstruct the original data, at a storage overhead of only 1.5x instead of 3x.<\/p>\n<p>The tradeoff is CPU and network cost on the recovery and read path. Reconstructing a missing cell requires reading the other cells in the group and running the reconstruction computation, meaningfully more expensive than replication&#8217;s copy-the-other-replica recovery, and a degraded read (one cell missing) is slower since it has to reconstruct on the fly rather than just reading a healthy replica elsewhere. Because of that, erasure coding is recommended for cold data, things accessed infrequently where storage savings matter more than read latency, like older logs or archival datasets, and it&#8217;s generally a poor fit for hot, frequently-read data or data with lots of small appends, since EC works best on large, static files.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">Walk through the HDFS write pipeline, and what happens if one DataNode in the pipeline fails mid-write.<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">HDFS Write Pipeline<\/span><span class=\"iq-badge iq-badge--hard\">Hard<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>When a client writes a file to HDFS, it doesn&#8217;t write to three DataNodes in parallel. It writes to the first DataNode in a pipeline, that node forwards the data to the second, and the second forwards it to the third, forming a chain. Data flows through in packets, not whole blocks at once, and acknowledgments flow back up the pipeline in reverse, so the client only considers a packet durably written once it gets an ack that&#8217;s propagated all the way back from the last node in the chain.<\/p>\n<p>If a DataNode in the middle of the pipeline fails during a write, the client, which actually manages the pipeline, not the NameNode, detects the failure through a missing ack or a connection error, removes the failed node, and asks the NameNode for a replacement to restore the replication factor. The pipeline is reconstructed with the new node added at the end, and the client resends any packets that weren&#8217;t fully acknowledged before the failure. The block gets a new generation stamp as part of this recovery, which matters: it&#8217;s how HDFS distinguishes a stale partial replica left on the failed node, or one that later rejoins, from the current correct version, so a DataNode that comes back online with an old generation stamp for that block gets its stale replica deleted rather than served to readers.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">A MapReduce job appears to succeed but you find duplicate or corrupted output files afterward. What&#039;s going on, and how does the OutputCommitter protocol prevent it?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Output Commit Protocol<\/span><span class=\"iq-badge iq-badge--hard\">Hard<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>This usually traces back to task attempts, not final tasks. MapReduce doesn&#8217;t run each logical task exactly once; it can run several attempts of the same task due to speculative execution or a retry after a failure, and if those attempts wrote directly to the job&#8217;s final output location, you&#8217;d end up with the same data written multiple times, or worse, a half-written file from a killed attempt sitting next to a complete one.<\/p>\n<p>The OutputCommitter protocol is what prevents that. Each task attempt writes its output to a private, attempt-specific temporary directory, never the final path. Only after an attempt is confirmed as the winner does commitTask() run, atomically moving that attempt&#8217;s output, via an HDFS rename, a cheap metadata operation, into the task&#8217;s final output location. If an attempt gets killed, because a speculative twin finished first, or the attempt failed, abortTask() runs instead and its temp directory just gets deleted, never touching real output. There&#8217;s also a job-level commitJob step, run once after every task has committed, which does the final &#8220;make the whole output visible&#8221; work, like writing a _SUCCESS marker, and that&#8217;s exactly why you should never trust output from a job directory missing that marker, since its absence usually means the job failed after some tasks committed but before the job-level commit finished.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">Your join is skewed, one reducer key has 90% of the records, and everything grinds to a crawl or OOMs. How do you actually fix this?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">Data Skew<\/span><span class=\"iq-badge iq-badge--hard\">Hard<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>First, confirm whether the skew is genuine business skew, one join key really does dominate, often a null or &#8220;unknown&#8221; foreign key value shared by a huge fraction of rows, versus an artifact of bad partitioning logic. Once you&#8217;ve confirmed it&#8217;s real key skew, the standard fix is salting: add a small random suffix to the skewed key on the large side of the join, artificially splitting one enormous reduce-side group into several smaller ones, and correspondingly explode the small side of the join by replicating each matching row across every salt value so every salted variant of the big key still finds its match.<\/p>\n<p>That distributes the work across many reducers instead of one, at the cost of extra shuffle volume on the replicated side, usually a good trade if the small side really is small.<\/p>\n<p><div class=\"iq-code not-prose\"><div class=\"iq-code__bar\"><span class=\"iq-code__lang\">sql<\/span><button class=\"iq-code__copy\" type=\"button\">Copy<\/button><\/div><pre><code class=\"language-sql\">\n\n\u2014 big side: append a random 0-9 salt to the join key\n\n\u2014 small side: explode each row into 10 copies, one per salt value\n\nSELECT b.*, s.*\n\nFROM big_table_salted b\n\nJOIN small_table_exploded s\n\n  ON b.salted_key = s.salted_key\n<\/code><\/pre><\/div><\/p>\n<p>Beyond salting, a map-side broadcast join sidesteps the shuffle and the skew entirely if the smaller table fits in memory, and on Spark, adaptive query execution&#8217;s skew-join handling detects skewed partitions at runtime and splits them automatically without hand-rolled salting. The tell that it&#8217;s skew rather than a slow node is in the counters: the straggler reducer&#8217;s input record count or shuffle bytes read sitting an order of magnitude above every other reducer&#8217;s, which rules out a hardware problem and points straight at key distribution.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">Why does NameNode heap memory become the real ceiling on how big an HDFS cluster can grow, and what actually happens when you get close to that limit?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">NameNode Heap Limits<\/span><span class=\"iq-badge iq-badge--hard\">Hard<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>Every file, directory, and block in HDFS is represented as an object living in the NameNode&#8217;s JVM heap, and the commonly cited rule of thumb is roughly 150 bytes of heap per object, with a file plus its blocks costing several objects. That means the ceiling on total files and blocks a cluster can hold isn&#8217;t a function of disk capacity at all, it&#8217;s purely a function of how much heap you can give one JVM before garbage collection pauses become unmanageable, since heaps in the hundreds of gigabytes run into serious full-GC pause problems that can make the NameNode unresponsive for tens of seconds, catastrophic when every HDFS operation across the whole cluster depends on that one process answering RPCs promptly.<\/p>\n<p>As you approach that ceiling, what you actually see well before an outright crash is degraded responsiveness: RPC queue times climb, client operations like opening files or listing directories start timing out intermittently, GC pause frequency and duration both rise, and eventually a stop-the-world pause can be long enough that ZooKeeper session timeouts fire and trigger an unwanted failover, even though nothing is technically &#8220;broken&#8221; other than the heap being too full. The real mitigations are architectural, not just adding RAM: HDFS federation to split the namespace across multiple NameNodes, aggressively consolidating small files into fewer, larger Parquet or ORC files, erasure coding to cut replica count for cold data, or moving cold data off HDFS entirely onto an object store that doesn&#8217;t share this single-process metadata bottleneck.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">What&#039;s the practical difference between YARN&#039;s Capacity Scheduler and Fair Scheduler, and how can preemption actually make things worse?<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">YARN Schedulers<\/span><span class=\"iq-badge iq-badge--hard\">Hard<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>The Capacity Scheduler organizes cluster resources into a hierarchy of queues, each guaranteed a configured percentage of cluster capacity, and a queue can burst above its guarantee into unused capacity from other queues, but gets it reclaimed through preemption if the owning queue needs it back. It&#8217;s built around predictability for multi-tenant clusters where different teams need a guaranteed slice, reserved capacity with the ability to opportunistically use spare cycles.<\/p>\n<p>The Fair Scheduler instead tries to give every running application, or every pool of applications, an equal share of resources over time, dynamically adjusting as new applications start and finish, so a single long-running job doesn&#8217;t hog the cluster while shorter jobs queue up behind it; new jobs get a fair share almost immediately rather than waiting for the big job to finish. Preemption is where both get genuinely tricky: when a scheduler decides to reclaim resources from a queue or app over its guaranteed or fair share, it doesn&#8217;t wait, it kills running containers immediately to free the resources. If a preempted container was mid-way through a long, non-checkpointed reduce task, that task&#8217;s progress is lost and restarts from scratch, and repeated preemption on a queue running expensive, monolithic tasks can actually reduce total cluster throughput compared to leaving preemption off, since you keep paying the cost of redone work. The practical mitigation is tuning preemption thresholds and grace periods generously enough that brief contention doesn&#8217;t trigger a kill, and structuring jobs so individual tasks are short enough that losing one to preemption isn&#8217;t expensive.<\/p>\n<p><\/div><\/div><\/div>\n<div class=\"iq-qa\"><button class=\"iq-qa__q\" type=\"button\" aria-expanded=\"false\"><span class=\"iq-qa__qtext\">Walk through how HDFS high availability with the Quorum Journal Manager actually prevents split-brain between two NameNodes.<\/span><span class=\"iq-qa__meta\"><span class=\"iq-qa__tag\">NameNode HA<\/span><span class=\"iq-badge iq-badge--hard\">Hard<\/span><span class=\"iq-qa__chev\" aria-hidden=\"true\"><\/span><\/span><\/button><div class=\"iq-qa__a\"><div class=\"iq-qa__a-inner\"><\/p>\n<p>The core problem is that an active and standby NameNode need to agree on exactly the same sequence of namespace edits, and if there&#8217;s ever a moment where both believe they&#8217;re active, a split-brain, they&#8217;ll diverge and corrupt the namespace. QJM replaces the older NFS-based shared edits directory with a quorum of JournalNodes, typically 3 or 5, and the active NameNode only considers an edit committed once a majority of JournalNodes have durably written it, the same majority-quorum principle other consensus systems rely on.<\/p>\n<p>Split-brain prevention comes down to fencing built directly into the write protocol. Every time a NameNode transitions to active it gets a new, strictly increasing epoch number, and it includes that epoch on every write request to the JournalNodes. A JournalNode rejects any write carrying an epoch lower than the highest one it has already seen. So if an old active NameNode gets network-partitioned, doesn&#8217;t realize it&#8217;s been failed over, and keeps trying to write edits, those writes carry a stale epoch and every JournalNode in the quorum refuses them, even if a majority of JournalNodes are still reachable from that stale NameNode&#8217;s point of view. That&#8217;s the real fencing mechanism, not a process-kill step (though ZKFC can do that too as a belt-and-suspenders measure), it&#8217;s a built-in rejection at the write layer that guarantees the stale NameNode&#8217;s edits never get durably committed no matter how hard it tries.<\/p>\n<p><\/div><\/div><\/div>\n<h2>How to prepare for a Hadoop interview in 2026<\/h2>\n<p>Skip another slide on the four-box HDFS diagram and just run a small cluster. Docker Compose or a single-node pseudo-distributed setup gets you a working NameNode, DataNode, and ResourceManager in under an hour. Once it&#8217;s up, break it on purpose: lower the block size to something tiny and load a directory with ten thousand small files, then watch what happens to NameNode heap and to a MapReduce job&#8217;s task count. Kill a DataNode mid-job and watch re-replication happen in the logs. Reading about the small-files problem is nothing like watching your own NameNode&#8217;s JVM heap climb because of a directory someone forgot to clean up.<\/p>\n<p>Across mock interviews run through LastRoundAI tagged data engineering and platform roles, the NameNode-versus-Secondary-NameNode question trips up more candidates than anything in the MapReduce section, even though MapReduce gets far more prep-guide attention. My guess is that &#8220;Secondary&#8221; sounds like &#8220;backup&#8221; in plain English, and that one word alone sends a lot of candidates into an answer that&#8217;s confidently wrong. I don&#8217;t have a clean percentage to put on how often that specific mix-up shows up, only that it comes up often enough across sessions to flag here.<\/p>\n<h2>Get comfortable defending your answers before an interviewer does it for you<\/h2>\n<p>Reading an answer about NameNode failover is not the same as explaining it live when an interviewer changes one detail on you, drops a DataNode mid-scenario, asks what happens if the JournalNode quorum itself loses a member. <a href=\"\/products\/mock-interviews\">LastRoundAI&#8217;s mock interview mode<\/a> runs data engineering and platform rounds with follow-up questions that adapt to what you actually said instead of a fixed script, and the free plan includes 15 credits a month that reset monthly rather than piling up. Starter is $19\/mo if fifteen sessions isn&#8217;t enough runway some months.<\/p>\n<p>If the harder part of the search right now is finding enough data engineering or platform roles that actually mention Hadoop, rather than passing the interview once you land one, <a href=\"\/products\/auto-apply\">Auto-Apply<\/a> queues tailored applications for your review, 10 a month on the free plan, up to 400 a month on the Ultimate plan, and nothing goes out until you approve it.<\/p>\n<p>Questions about either product go to contact@lastroundai.com. That&#8217;s the only inbox we check.<\/p>\n<div class=\"iq-sources not-prose\"><div class=\"iq-sources__title\">Sources &amp; further reading<\/div><ul class=\"iq-sources__list\"><li><a href=\"https:\/\/sortbenchmark.org\/YahooHadoop.pdf\" target=\"_blank\" rel=\"nofollow noopener\">Owen O&#039;Malley, Yahoo!: TeraByte Sort on Apache Hadoop (2008)<\/a><\/li><li><a href=\"https:\/\/hadoop.apache.org\/docs\/stable\/hadoop-project-dist\/hadoop-hdfs\/HdfsDesign.html\" target=\"_blank\" rel=\"nofollow noopener\">Apache Hadoop Documentation: HDFS Architecture<\/a><\/li><li><a href=\"https:\/\/hadoop.apache.org\/docs\/stable\/hadoop-project-dist\/hadoop-hdfs\/HDFSHighAvailabilityWithQJM.html\" target=\"_blank\" rel=\"nofollow noopener\">Apache Hadoop Documentation: HDFS High Availability with QJM<\/a><\/li><\/ul><\/div>\n","protected":false},"excerpt":{"rendered":"<p>In April 2008 a 910-node Yahoo cluster sorted a full terabyte of data in 209 seconds, the first time an open-source system had won the general-purpose terabyte sort benchmark and beating the prior record of 297 seconds (Owen O&#8217;Malley, Yahoo!, TeraByte Sort on Apache Hadoop, 2008). Seven months later Google&#8217;s own MapReduce implementation did the&#8230;<\/p>\n","protected":false},"author":6,"featured_media":1607,"comment_status":"open","ping_status":"closed","template":"","meta":{"_kad_post_transparent":"","_kad_post_title":"","_kad_post_layout":"","_kad_post_sidebar_id":"","_kad_post_content_style":"","_kad_post_vertical_padding":"","_kad_post_feature":"","_kad_post_feature_position":"","_kad_post_header":false,"_kad_post_footer":false,"_kad_post_classname":"","footnotes":""},"tags":[],"class_list":["post-1281","iq","type-iq","status-publish","has-post-thumbnail","hentry"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.8 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Hadoop Interview Questions (2026) | LastRoundAI<\/title>\n<meta name=\"description\" content=\"Real Hadoop interview questions for 2026: HDFS architecture, MapReduce, YARN, Hadoop 1 vs 2 vs 3, Hive, and the small-files problem, explained.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/lastroundai.com\/interview-questions\/hadoop\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Hadoop Interview Questions (2026) | LastRoundAI\" \/>\n<meta property=\"og:description\" content=\"Real Hadoop interview questions for 2026: HDFS architecture, MapReduce, YARN, Hadoop 1 vs 2 vs 3, Hive, and the small-files problem, explained.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/lastroundai.com\/interview-questions\/hadoop\" \/>\n<meta property=\"og:site_name\" content=\"LastRound AI\" \/>\n<meta property=\"article:modified_time\" content=\"2026-07-19T05:24:08+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/07\/iq-hadoop-og.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"630\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"19 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/hadoop\",\"url\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/hadoop\",\"name\":\"Hadoop Interview Questions (2026) | LastRoundAI\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/hadoop#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/hadoop#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/07\\\/iq-hadoop-og.png\",\"datePublished\":\"2026-07-19T04:26:09+00:00\",\"dateModified\":\"2026-07-19T05:24:08+00:00\",\"description\":\"Real Hadoop interview questions for 2026: HDFS architecture, MapReduce, YARN, Hadoop 1 vs 2 vs 3, Hive, and the small-files problem, explained.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/hadoop#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/hadoop\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/hadoop#primaryimage\",\"url\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/07\\\/iq-hadoop-og.png\",\"contentUrl\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/07\\\/iq-hadoop-og.png\",\"width\":1200,\"height\":630,\"caption\":\"Hadoop interview questions \u2014 LastRoundAI\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/hadoop#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/lastroundai.com\\\/blog\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Interview Questions\",\"item\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Hadoop Interview Questions (2026): HDFS, MapReduce &#038; YARN Q&#038;A\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/\",\"name\":\"LastRound AI\",\"description\":\"Interview Assistant prep, tech careers and AI tools\",\"publisher\":{\"@id\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/#organization\",\"name\":\"LastRound AI\",\"url\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/06\\\/lastroundai-transprant-logo-optimized-BxEo2Wtq.png\",\"contentUrl\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/06\\\/lastroundai-transprant-logo-optimized-BxEo2Wtq.png\",\"width\":400,\"height\":400,\"caption\":\"LastRound AI\"},\"image\":{\"@id\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Hadoop Interview Questions (2026) | LastRoundAI","description":"Real Hadoop interview questions for 2026: HDFS architecture, MapReduce, YARN, Hadoop 1 vs 2 vs 3, Hive, and the small-files problem, explained.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/lastroundai.com\/interview-questions\/hadoop","og_locale":"en_US","og_type":"article","og_title":"Hadoop Interview Questions (2026) | LastRoundAI","og_description":"Real Hadoop interview questions for 2026: HDFS architecture, MapReduce, YARN, Hadoop 1 vs 2 vs 3, Hive, and the small-files problem, explained.","og_url":"https:\/\/lastroundai.com\/interview-questions\/hadoop","og_site_name":"LastRound AI","article_modified_time":"2026-07-19T05:24:08+00:00","og_image":[{"width":1200,"height":630,"url":"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/07\/iq-hadoop-og.png","type":"image\/png"}],"twitter_card":"summary_large_image","twitter_misc":{"Est. reading time":"19 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/lastroundai.com\/interview-questions\/hadoop","url":"https:\/\/lastroundai.com\/interview-questions\/hadoop","name":"Hadoop Interview Questions (2026) | LastRoundAI","isPartOf":{"@id":"https:\/\/lastroundai.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/lastroundai.com\/interview-questions\/hadoop#primaryimage"},"image":{"@id":"https:\/\/lastroundai.com\/interview-questions\/hadoop#primaryimage"},"thumbnailUrl":"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/07\/iq-hadoop-og.png","datePublished":"2026-07-19T04:26:09+00:00","dateModified":"2026-07-19T05:24:08+00:00","description":"Real Hadoop interview questions for 2026: HDFS architecture, MapReduce, YARN, Hadoop 1 vs 2 vs 3, Hive, and the small-files problem, explained.","breadcrumb":{"@id":"https:\/\/lastroundai.com\/interview-questions\/hadoop#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/lastroundai.com\/interview-questions\/hadoop"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/lastroundai.com\/interview-questions\/hadoop#primaryimage","url":"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/07\/iq-hadoop-og.png","contentUrl":"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/07\/iq-hadoop-og.png","width":1200,"height":630,"caption":"Hadoop interview questions \u2014 LastRoundAI"},{"@type":"BreadcrumbList","@id":"https:\/\/lastroundai.com\/interview-questions\/hadoop#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/lastroundai.com\/blog"},{"@type":"ListItem","position":2,"name":"Interview Questions","item":"https:\/\/lastroundai.com\/interview-questions"},{"@type":"ListItem","position":3,"name":"Hadoop Interview Questions (2026): HDFS, MapReduce &#038; YARN Q&#038;A"}]},{"@type":"WebSite","@id":"https:\/\/lastroundai.com\/blog\/#website","url":"https:\/\/lastroundai.com\/blog\/","name":"LastRound AI","description":"Interview Assistant prep, tech careers and AI tools","publisher":{"@id":"https:\/\/lastroundai.com\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/lastroundai.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/lastroundai.com\/blog\/#organization","name":"LastRound AI","url":"https:\/\/lastroundai.com\/blog\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/lastroundai.com\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/06\/lastroundai-transprant-logo-optimized-BxEo2Wtq.png","contentUrl":"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/06\/lastroundai-transprant-logo-optimized-BxEo2Wtq.png","width":400,"height":400,"caption":"LastRound AI"},"image":{"@id":"https:\/\/lastroundai.com\/blog\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/iq\/1281","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/iq"}],"about":[{"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/types\/iq"}],"author":[{"embeddable":true,"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/comments?post=1281"}],"version-history":[{"count":3,"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/iq\/1281\/revisions"}],"predecessor-version":[{"id":1782,"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/iq\/1281\/revisions\/1782"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/media\/1607"}],"wp:attachment":[{"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/media?parent=1281"}],"wp:term":[{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/tags?post=1281"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}