Walk into your next interview ready.

Present, past, future: what you do now, the experience that got you here, and why this role is the logical next step. Keep it under two minutes.

Pick one strength the job needs and prove it with a short, specific example.

Name a real, non-critical weakness and the concrete steps you are taking to improve it.

Use STAR. Spend most of the answer on the actions you personally took.

Show a method: break the work down, agree priorities early, communicate risks before they become surprises.

Mention impact versus urgency, checking priorities with your manager, and a tool you use to track work.

Explain how you learned (docs, small prototype, asking experts) and what you delivered with it.

Validation at ingestion, automated tests, monitoring for anomalies, and clear ownership when something breaks.

Name real sources you use — newsletters, communities, side projects — and something you recently learned.

Focus on understanding their view and the professional steps you took. Never criticise the person.

Reference something specific: a product, their users, a talk or engineering blog post. Link it to your goals.

Leadership is not a title. Show how you set direction, unblocked others and delivered the result.

Give an example of feedback you received, what you changed, and the improvement it led to.

Walk through your process: reproduce, isolate, form hypotheses, test, fix, prevent recurrence.

Planning ahead, clear communication with the team and healthy habits outside work. Keep it practical.

Stay positive and forward-looking: growth, new challenges, the kind of work you want to do more of.

Be genuine. Connect the passion to how you solve problems or the impact you want to make.

It prevents rework, surfaces problems early and builds trust. Give a moment where it made a difference.

Tell your manager early, explain why, and offer options: reduced scope, extra help or a new date.

Ask clarifying questions, write down your understanding, confirm it, and check in early with a draft.

Assess impact, inform the team, fix or roll back, then write up the cause so it does not recur.

Acknowledge it, assess the effort and trade-off, and let the product owner decide on priorities.

Raise it respectfully with evidence. If the team still decides otherwise, commit fully to the decision.

Official docs, a small proof of concept, and asking a colleague who knows it. Share what you learn.

Speak to them privately first; they may be blocked. Offer help, then escalate only if it continues.

Raise it promptly and calmly through the right channel. Protecting users comes before avoiding awkwardness.

Spark keeps intermediate data in memory and offers high-level APIs (SQL, DataFrames, streaming); MapReduce writes to disk between steps, so it is slower for iterative work.

ETL transforms before loading; ELT loads raw data into the warehouse first and transforms there, which suits scalable cloud warehouses.

Sources, ingestion, storage, transformation, orchestration, serving, plus monitoring and data quality checks throughout.

Read the execution plan, index filtered and joined columns, avoid SELECT *, filter early and partition large tables.

Splitting data by a key such as date so queries scan only what they need — faster and cheaper, and easier to reprocess.

Star: a fact table surrounded by denormalised dimensions. Snowflake: dimensions normalised into sub-tables, saving space at the cost of more joins.

Immutable raw data, dated snapshots or table formats with time travel (Delta, Iceberg), and transformation code in Git.

Separation of storage and compute, elastic scaling, managed maintenance and pay-for-use pricing.

Cheap storage for raw data in any format, schema-on-read flexibility, and a single source for analytics and ML.

Schema checks, null and uniqueness tests, row-count and freshness checks, using tools like dbt tests or Great Expectations.

Reliable training data, feature pipelines, data versioning and serving data to models in production.

Automated tests on pull requests, linting SQL, deploying DAGs and dbt models through a pipeline rather than by hand.

DAGs with clear dependencies, retries, SLAs and alerting; idempotent tasks so reruns are safe.

Access control, data catalogues and lineage, ownership, retention policies and handling personal data lawfully.

Tables with fixed schemas; JSON or XML with flexible structure; free text, images and audio with no predefined model.

Event source → message broker (Kafka) → stream processor (Spark Streaming, Flink) → low-latency store → dashboard. Discuss late data and failures.

Inventory and assess, choose a migration pattern, migrate in phases, validate counts and checksums, then cut over with a rollback plan.

Communicate impact, check logs and recent changes, fix or roll back, backfill missing data, then add a test or alert for next time.

Encryption in transit and at rest, least-privilege access, masking personal data, audit logs and following laws like the Kenya Data Protection Act or GDPR.

Profile to find the bottleneck, process incrementally, push filters down, partition, parallelise and right-size compute.

Land raw data as-is, standardise into a common schema, map keys between systems and document every transformation.

Start with the questions the business needs answered, then events to track, storage, models and who consumes the data.

Lifecycle rules to cheaper tiers, compression and columnar formats, deleting unused data and partition pruning.

Quantify it, trace lineage back to the source, inform affected users, fix the root cause and add a reconciliation check.

Incremental processing, partitioning, distributed compute, autoscaling and removing single-machine bottlenecks.

SELECT MAX(salary) FROM employees WHERE salary < (SELECT MAX(salary) FROM employees); or use DENSE_RANK() and filter for rank 2.

OLTP handles many small, fast transactions (orders, payments); OLAP handles large analytical queries over historical data.

Identify entities and relationships, normalise, choose keys and constraints, then index for the main access patterns.

Flexible schemas and horizontal scaling, but weaker joins and often relaxed consistency. Choose by access pattern.

1NF atomic values, 2NF no partial dependencies, 3NF no transitive dependencies — reducing duplication and update anomalies.

Indexes speed up reads on filtered, joined and sorted columns but slow down writes and use space. Index for real queries.

Atomicity, Consistency, Isolation, Durability — the guarantees that keep transactions reliable even when things fail.

INNER for matches only, LEFT/RIGHT to keep all rows from one side, FULL for everything, CROSS for every combination.

Split data across nodes by a shard key; choose a key that spreads load evenly and keeps related data together.

Primary-replica replication for read scaling and backup; automatic failover promotes a replica when the primary fails.

WHERE filters rows before grouping; HAVING filters groups after aggregation.

Profile first, then decide per column to drop, impute or flag. Remove duplicates and document every decision.

How likely results this extreme would be if there were no real effect. It does not measure how big the effect is.

Verify the data, segment by region, product and channel, check seasonality, then recommend an action.

Precision when false positives are costly, recall when false negatives are costly; F1 to balance them.

Define one metric and hypothesis, calculate sample size, randomise users, run for a full cycle and check significance.

A model that memorises training data. Use cross-validation, simpler models, regularisation and more data.

Line for trends over time, bar for comparisons, scatter for relationships, and avoid pie charts with many slices.

Built for one audience and decision, a few key metrics at the top, consistent definitions and no clutter.

Ice cream sales and drowning both rise in summer; heat drives both. Only experiments establish cause.

Start with the O(n²) loop, then improve to O(n) with a hash map of values already seen.

DNS, TCP and TLS, HTTP request, server response, then parsing, styling and rendering the page.

Authentication proves who you are; authorisation decides what you may do.

Clarify requirements, define the API, generate short codes, store mappings, cache popular links and plan for scale.

Problem, your role, stack choices, one hard decision or bug, and what you would improve.

Unit, integration and end-to-end tests, run automatically in CI before merging.

A process has its own memory; threads share their process's memory, making them lighter but needing care with shared state.

Resources identified by URLs; GET reads, POST creates, PUT/PATCH update, DELETE removes; responses use status codes.

Measure first, then compress and lazy-load images, reduce JavaScript, cache assets and fix slow API calls.

SQL gives schemas, joins and transactions; NoSQL gives flexible documents and easy scaling for simple access patterns.

Merge preserves history with a merge commit; rebase rewrites commits onto a new base for a linear history. Never rebase shared branches.

Check the query plan, add the right index, fetch only needed columns, avoid N+1 queries and cache repeated reads.

Lists are mutable; tuples are immutable, hashable when their contents are, and slightly faster.

A concise way to build lists: [x * 2 for x in nums if x > 0]. Readable for simple cases only.

*args collects extra positional arguments into a tuple; **kwargs collects extra keyword arguments into a dict.

A function that yields values lazily, one at a time — memory-efficient for large or infinite sequences.

try/except for specific exceptions, else for success, finally for cleanup; never use a bare except.

== compares values; is checks whether two names point to the same object.

Stream it with the csv module or pandas read_csv(chunksize=...), processing one chunk at a time.

Functions that wrap another function to add behaviour, such as logging, caching or access checks.

Explain the options, how you weighed them, who you consulted, the decision and what happened.

Name it plainly and back it with an example of how it helped a team deliver.

Regular one-to-ones, pairing, stretch tasks with support, and helping them set their own goals.

Private, specific, about behaviour not personality, with agreed next steps and follow-up.

Hear each side separately, find the root cause, agree a shared goal and a way forward together.

Find the cause first, set clear expectations, offer support and track progress fairly.

Planning and prioritising work, unblocking the team, reviews, stakeholder communication and developing people.