HCIP-Big Data Developer study plan

Map every FusionInsight component (HDFS, YARN, Hive, HBase, Spark, Flink, Kafka, Loader, Flume, Sqoop, ZooKeeper, Manager) to its role, so you can state what each one stores or schedules without notes

Describe the HDFS write pipeline and read path end to end, naming NameNode, DataNode, JournalNode, and client responsibilities at each step

Configure replication factor, block size, and rack awareness for a stated workload, and justify each value you choose

Diagnose three HDFS failure scenarios (DataNode loss, NameNode failover, full disk) and state the recovery behavior

Write a Java or Scala HDFS client program that creates, appends, lists, and deletes files, and handles permissions errors explicitly

Implement a MapReduce job with a custom Writable, a Combiner, and a Partitioner, then explain how each changes shuffle volume

Configure a YARN application with memory, vCore, and queue settings, and predict what happens when the container request exceeds the queue capacity

Trace one job through ResourceManager, NodeManager, ApplicationMaster, and containers, and identify where a hang would surface

Model a Hive warehouse with internal and external tables, partitions, and buckets, and state when each storage choice is correct

Write HiveQL covering joins, window functions, lateral views, and dynamic partitioning, and explain the execution plan for one of them

Design an HBase rowkey for a stated access pattern that avoids hot spots, and defend the salt or hash prefix you chose

Build an HBase table with column families sized for the read/write mix, and explain how MemStore, BlockCache, and compaction affect latency

Compare Hive-on-HBase, Phoenix-style access, and direct HBase API access for one query requirement

Write Spark transformations and actions that avoid unnecessary shuffles, and identify wide dependencies in your own code

Persist a DataFrame at the right storage level and measure or reason about the effect on a repeated aggregation

Explain Spark's memory model, executor and driver sizing, and how a skewed key produces a straggler task

Rewrite a Spark SQL query using broadcast join hints and partition pruning, and state the expected plan change

Build a Flink DataStream pipeline with event time, watermarks, and a windowed aggregation, and explain late-event handling

Choose between keyed state and operator state for a stated use case, and configure checkpointing and restart strategy

Define a Kafka topic with partitions and replication suited to a stated throughput, and explain consumer group rebalancing

Assemble an ingestion path with Flume or Sqoop or Loader into HDFS or Hive, and state where duplicates or partial files can appear

Explain exactly-once versus at-least-once across the Kafka-to-Flink boundary and what each requires

Compare Spark Structured Streaming and Flink for one stated latency and correctness requirement, and justify a choice

Tune a streaming job's parallelism, checkpoint interval, and state backend, and predict the effect of each change

Convert one batch Spark job into a streaming equivalent and identify the state you must carry

Reproduce and fix a backpressure or checkpoint-timeout symptom in a streaming pipeline

Configure HDFS and Hive permissions with roles, ACLs, and Ranger-style policies, and verify a denied access produces the expected error

Design a multi-tenant layout with queues, directories, and resource limits, and state what isolates tenants from each other

Diagnose a slow job using stage timing, spill metrics, GC behavior, and data skew evidence, and name the fix for each cause

Explain how to read a NameNode heap problem, a small-files problem, and a YARN queue saturation problem from symptoms alone

Answer timed practice sets weighted by domain percentage, and log every miss by domain and cause

Re-derive the weakest three domain summaries from memory without opening your notes

Redo every missed item and state why the correct answer beats each distractor

Review the security, tuning, and ingestion domains last, since they are the smallest and easiest to let slip