· 6 min read

Top Interview Questions by Technology

Few interview question

Below are the technologies and skills listed in my CV and the single best question an interviewer is likely to ask for each. Answer outlines are pragmatic and concise; snippets are minimal.

Covered technologies and skills

  • TypeScript, JavaScript, React, Next.js, Astro, HTML, CSS, Tailwind CSS, Angular, Vite
  • Flutter, React Native
  • Sitecore CMS, Sanity, Prestashop
  • Node.js, GraphQL, NoSQL, Neo4j, SQL Server, MySQL
  • Firebase
  • AWS (CDK, S3, CloudWatch, VPC, API Gateway), Vercel
  • GitHub Actions, CI/CD, Monorepo, RushJS, Codemagic
  • ElasticSearch, Azure, MongoDB, Coveo
  • TensorFlow (ML), OpenStreetMap API, Google Cloud
  • C#, ASP.NET
  • Laravel/PHP
  • Architecture, Team Leadership, Code Reviews, Scrum, Analysis (functional/technical)

Core Web / Frontend

  • TypeScript/JavaScript — What problem does TypeScript really solve in large frontends, and where does it not help?

    • Answer outline: soundness vs JS ergonomics; boundary checks (API/runtime); generics + discriminated unions; pitfalls (any, widening, structural typing); runtime validation (zod) complement.
    type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
function parseIntSafe(s: string): Result<number, 'NaN'> {
  const n = Number.parseInt(s, 10);
  return Number.isNaN(n) ? { ok: false, error: 'NaN' } : { ok: true, value: n };
}

  • React — How do you prevent unnecessary renders, and when does memoization backfire?

    • Answer outline: referential stability (useMemo/useCallback), React.memo, keying, context segmentation; memo costs; profiling; change-frequency tradeoffs.

  • Next.js — When do you place logic in Server Components vs Client Components, and how do you stream data safely?

    • Answer outline: RSC for data/IO, Client for interactivity; streaming with Suspense; caching with fetch(); edge/runtime constraints; security boundaries.

  • Astro — Why island architecture helps performance on content-heavy sites, and how to hydrate only what’s needed.

    • Answer outline: partial hydration, client directives (client:idle, client:visible), content collections, SSR vs static.

  • HTML/CSS — How do you build an accessible component library without shipping CSS bloat?

    • Answer outline: semantic HTML, focus states, prefers-reduced-motion; CSS layering; utility-first with composition; purge/CSSTree; container queries.

  • Tailwind CSS — How do you keep Tailwind maintainable at scale?

    • Answer outline: design tokens in theme, extract UI primitives, enforce with ESLint/stylelint, safelist/purge strategy.

  • Angular — Change detection strategies and when to use OnPush/signals.

    • Answer outline: zone.js cost, pure vs impure pipes, immutability; signals for fine-grain updates.

  • Vite — What makes Vite fast and how do you optimize prod builds?

    • Answer outline: ESM dev server; esbuild pre-bundle; Rollup in prod; code-splitting; cache groups.

Mobile / Cross-platform

  • Flutter — Explain render pipeline (widgets → elements → render objects) and managing rebuilds.

    • Answer outline: const widgets, keys, InheritedWidget vs Provider/Riverpod, layout/paint phases, avoiding setState waterfalls.

  • React Native — How does the bridge architecture differ from the Fabric/JSI model?

    • Answer outline: async bridge limits; JSI/TurboModules/Fabric for sync and lower overhead; perf implications.

Frameworks / CMS / Commerce

  • Sitecore CMS — How do you design a multi-tenant content model that scales without template explosion?

    • Answer outline: data vs branch templates, composable fields, inheritance rules, SXA considerations, caching.

  • Sanity — How do GROQ and portable text influence your frontend data shape?

    • Answer outline: denormalized GROQ projections; strong typing via zod/TS; portable text renderers.

  • Prestashop — Safe customization path that survives upgrades?

    • Answer outline: override patterns, child themes, module boundaries, extension points, upgrade testing.

Backend / Data

  • Node.js — How do you handle concurrency and CPU-bound tasks in Node?

    • Answer outline: event loop + libuv; clustering, worker_threads, queue offloading; backpressure with streams.

  • GraphQL — How do you prevent N+1 queries and secure the schema?

    • Answer outline: DataLoader batching, pagination/limits, auth at field/resolver, complexity limits, persisted ops.

  • NoSQL (MongoDB/Dynamo) — Modeling reservations/search: when to denormalize vs index?

    • Answer outline: access patterns first, write amplification trade-offs, TTL, secondary indexes, hot partition avoidance.

  • Neo4j — When does graph outperform relational and how to design relationships?

    • Answer outline: relationship-first queries, path finding, constraints, APOC, cardinality control.

  • SQL Server / MySQL — Given a slow search, where do you start?

    • Answer outline: EXPLAIN plans, correct indexes (covering/compound), sargable predicates, avoid functions on indexed cols.

Cloud / DevOps

  • AWS (CDK, S3, CloudWatch, VPC, API Gateway) — Sketch a minimal, secure public API with logging.

    • Answer outline: VPC with subnets, API Gateway + Lambda, least-priv IAM, CloudWatch logs/metrics/alarms, WAF if needed.
    // AWS CDK (TypeScript) - API + Lambda
const api = new apigw.RestApi(this, 'Api');
const fn = new lambda.Function(this, 'Fn', {
  runtime: lambda.Runtime.NODEJS18_X,
  code: lambda.Code.fromAsset('dist'),
  handler: 'index.handler',
});
api.root.addResource('health').addMethod('GET', new apigw.LambdaIntegration(fn));

  • Vercel — Cold starts vs Edge vs Node and when to pick each.

    • Answer outline: latency profiles, runtime limits, caching headers, ISR/SSR trade-offs.

  • GitHub Actions — Author a fast CI pipeline for a monorepo.

    • Answer outline: matrix builds, path filters, caching (npm/bun), artifacts, required checks, concurrency groups.
    name: ci
on: [push, pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 20, cache: 'npm' }
      - run: npm ci
      - run: npm run -w web build

  • Monorepo / RushJS — What problem does Rush solve over plain workspaces?

    • Answer outline: deterministic builds, change detection, version policies, build orchestration, publishing.

  • CI/CD (general) — How do you design CI that’s both fast and trustworthy?

    • Answer outline: caching + hermetic builds, test sharding, flaky test quarantine, artifact promotion, supply-chain (SLSA) basics.

  • Codemagic — Scaling mobile CI: caching, code signing, and store submissions.

    • Answer outline: keystore management, cache gradle/pods, parallel jobs, submission steps.

Cloud Data & Search

  • Firebase — How do you secure multi-tenant data with rules and avoid hot paths?

    • Answer outline: Firestore rules with custom claims, composite indexes, batched writes, rate limits, Cloud Functions for heavy work.

  • ElasticSearch — Designing relevance for hotel/city search.

    • Answer outline: analyzers, n-grams, BM25 tuning, function scores (popularity/geo), aggregations, index lifecycle.

  • Azure / MongoDB / Coveo — Where do each fit in your search/analytics stack?

    • Answer outline: Azure hosting/integration; Mongo for flexible docs; Coveo for SaaS relevance pipelines and analytics.

ML / Maps / Ops

  • TensorFlow (ML) — How would you ship an on-device model in a Flutter app?

    • Answer outline: tflite conversion, quantization (int8), delegates, A/B via remote config, privacy.

  • OpenStreetMap API — Efficiently rendering and caching tiles/geodata on mobile.

    • Answer outline: tile caching, vector vs raster, offline packs, rate limits, map matching.

  • Google Cloud — Choosing between Cloud Run, Functions, and GKE for a web API.

    • Answer outline: scale-to-zero costs, cold start trade-offs, long-running tasks, VPC access, IAM/service accounts.

Microsoft stack

  • C# / ASP.NET — Async pitfalls in ASP.NET and how to fix them.
    • Answer outline: async all the way, ConfigureAwait, thread pool starvation, HttpClient reuse, DI scopes.

PHP / Laravel

  • Laravel/PHP — Eloquent N+1, queues, and caching strategy for a busy API.
    • Answer outline: with()/eager loading, jobs/queues, Redis tags, horizon, octane, config/opcache.

Process & Leadership

  • Architecture — How do you design for change? (Bounded contexts + seams.)

    • Answer outline: hexagonal/ports-adapters, anti-corruption layers, event-driven boundaries, contract tests.

  • Team Leadership — What’s your playbook for turning around a legacy codebase?

    • Answer outline: health checks, error budgets, observability, strangler-fig refactor, CI gates, docs-as-code.

  • Code Reviews — How do you raise quality without killing velocity?

    • Answer outline: checklists, small PRs, bots for trivialities, pair/MOB on risky code, metrics that matter.

  • Scrum — How to avoid story-point theater while staying predictable?

    • Answer outline: throughput metrics, WIP limits, DoR/DoD, slice by outcome, scope guardrails.
Share:
Back to Blog