KPMG Software Engineer Interview Guide

Use the sliding window technique with a hash map to track character positions. Time complexity O(n), space O(min(n,m)) where m is charset size. Explain how you'd handle Unicode characters vs ASCII.

Combine a hash map and dynamic array. Hash map stores value-to-index mapping, array stores actual values. For delete, swap with last element. Explain why this maintains O(1) for all operations.

Use recursion with min/max bounds that tighten as you traverse. Common mistake is only checking immediate children. Discuss in-order traversal alternative and when each approach is better.

Use a doubly-linked list with a hash map. Hash map provides O(1) lookup, linked list maintains access order. Explain why doubly-linked vs singly-linked, and how to handle capacity constraints.

Use binary search on the smaller array to partition both arrays. Key insight is finding the correct partition point. Discuss why this is better than merging arrays, and handle edge cases like empty arrays.

Show insert, search, and startsWith operations. Discuss time complexity O(m) where m is key length. Explain real-world applications like autocomplete, spell checkers, and IP routing.

Sort intervals by start time first O(n log n). Then iterate and merge if current overlaps with previous. Discuss edge cases like contained intervals, adjacent intervals, and single interval.

Use pre-order traversal with null markers. Explain why pre-order vs other traversals, how to handle reconstruction, and space considerations for unbalanced trees vs balanced trees.

Compare three approaches - sorting O(n log n), max heap O(n log k), and quickselect O(n) average case. Explain when you'd choose each approach based on constraints like k value and array size.

Use Floyd's cycle detection (slow and fast pointers). Explain why this works mathematically, how to find cycle entry point, and the O(1) space advantage over hash set approach.

Use backtracking with recursion. Discuss time complexity O(4^n) worst case, space O(n) for recursion stack. Explain how to optimize with iterative approach using queue if needed.

Cover key generation strategies (base62 encoding, hash-based), database schema, caching layer (Redis), load balancing, and analytics tracking. Discuss trade-offs between different approaches and how to handle 100K+ requests/sec.

Discuss consistent hashing for key distribution, replication strategies, eviction policies (LRU, LFU), cache invalidation, and handling node failures. Compare Redis vs Memcached and when to use each.

Use message queues (Kafka, RabbitMQ) for reliable delivery, separate workers for each channel, priority queues, retry mechanisms, and rate limiting. Discuss how to handle millions of concurrent users.

Cover WebSocket connections, message queue for async processing, database sharding for scalability, read receipts, typing indicators, and offline message storage. Discuss how to handle message ordering and consistency.

Compare token bucket, leaky bucket, and fixed/sliding window algorithms. Discuss distributed rate limiting using Redis, handling clock synchronization, and trade-offs between accuracy and performance.

Use blob storage (S3), async processing with queues, chunked uploads for large files, virus scanning, thumbnail generation, and CDN for distribution. Discuss handling upload failures and resume capability.

Use trie data structure for prefix matching, caching popular queries, ranking by frequency/freshness, handling typos with fuzzy matching, and personalization. Discuss how to update suggestions in real-time.

Cover distributed tracing (OpenTelemetry), centralized logging (ELK stack), metrics collection (Prometheus), alerting rules, log aggregation, and retention policies. Discuss handling log volume at scale.

Cover database schema for spots/floors/vehicles, reservation system, payment processing, real-time updates using WebSockets or polling, and handling concurrent bookings. Discuss ACID properties for transactions.

Discuss CDN for content delivery, adaptive bitrate streaming, encoding pipeline, recommendation system, user profile management, and analytics. Cover how Netflix handles regional content and DRM.

Cover Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. Give concrete code examples for each. Explain how these principles improve maintainability and testability.

Discuss test pyramid (unit > integration > E2E), code coverage goals (70-80% is reasonable), testing edge cases and error paths, using mocks/stubs, and TDD approach. Explain when NOT to write tests.

Use backward-compatible changes, deploy in phases (add new column, migrate data, update code, remove old column), feature flags, and rollback strategies. Discuss tools like Flyway or Liquibase.

Discuss feature branches, pull requests, code reviews, commit message conventions, rebasing vs merging, and CI/CD integration. Explain how you prevent conflicts through good communication and small PRs.

Cover automated testing, linting, code reviews, static analysis tools, coding standards, documentation, and technical debt management. Discuss balancing speed with quality.

Start with domain-driven design to identify bounded contexts, extract services incrementally (strangler fig pattern), use API gateway, implement service mesh, and establish observability. Discuss when NOT to use microservices.

Cover automated testing, linting, security scanning, artifact building, deployment stages (dev/staging/prod), rollback mechanisms, and monitoring. Discuss tools like Jenkins, GitHub Actions, or CircleCI.

Categorize debt (deliberate vs accidental), quantify impact on velocity, allocate regular time for cleanup (20% rule), and document decisions. Discuss using tech debt registers and prioritization frameworks.

Use APM tools (New Relic, DataDog), check database query performance, analyze N+1 queries, review caching strategy, check network latency, and CPU/memory usage. Explain systematic debugging approach.

Use EXPLAIN to analyze query plan, add appropriate indexes, avoid SELECT *, denormalize if needed, use query caching, and consider read replicas. Discuss trade-offs between read and write performance.

Discuss generational GC, young/old generation, GC algorithms (Serial, Parallel, CMS, G1), monitoring GC pauses, tuning heap size, and when to use off-heap storage. Focus on JVM if applicable.

Profile with memory analyzers, identify memory leaks, optimize data structures, use object pooling, compress data, lazy loading, and streaming for large datasets. Discuss monitoring tools and metrics.

Cover code splitting, lazy loading, image optimization, CDN usage, browser caching, minification, tree shaking, and critical CSS. Discuss Core Web Vitals and measuring with Lighthouse.

Cover authentication (JWT, OAuth), authorization (RBAC), input validation, SQL injection prevention, XSS protection, CSRF tokens, rate limiting, and HTTPS. Discuss OWASP Top 10 vulnerabilities.

Use bcrypt/Argon2 for hashing with salts, never store plain text, implement MFA, use secure session management, have password complexity requirements, and handle password reset securely. Discuss brute force protection.

Use encryption at rest (AES-256), TLS for transmission, tokenization for sensitive fields, access control at database level, audit logging, and key management systems. Discuss compliance requirements (GDPR, PCI-DSS).

Use STAR method (Situation, Task, Action, Result). Emphasize systematic approach, communication with team, using logs/metrics, and lessons learned. Show how you prevented similar issues in the future.

Show respect for others' opinions, use data to support your position, be willing to compromise, and focus on project goals over ego. Explain the outcome and what you learned.

Mention specific resources (blogs, conferences, courses), side projects, open source contributions, and how you evaluate which technologies to learn. Show continuous learning mindset.

Explain the business context, what you prioritized and why, how you managed technical debt, and lessons learned. Show pragmatic thinking and business awareness.

Choose a project that showcases technical depth, problem-solving skills, and resilience. Discuss specific challenges, your approach, collaboration with team, and measurable outcomes.

Discuss reading documentation, running the code locally, asking questions, pair programming, starting with small tasks, and building mental models. Show systematic and humble approach.

Use sorted character signature as hash key, group anagrams together. For Google scale, discuss MapReduce, distributed hash tables, and handling billions of words. Show understanding of distributed computing.

Discuss indexing pipeline, inverted index data structure, distributed caching, geographically distributed data centers, and load balancing. Show understanding of ranking algorithms and personalization at scale.

Cover relevance scoring factors (engagement, recency, connection strength), machine learning models, A/B testing framework, and handling billions of posts. Discuss ethical considerations like echo chambers.

Use DFS with color marking (white/gray/black) or union-find for undirected graphs. Discuss time complexity O(V+E) and when this matters for Facebook's social graph scale (billions of users).

Cover collaborative filtering, content-based filtering, hybrid approaches, real-time updates, handling cold start problem, and A/B testing. Discuss how Amazon uses purchase history and browsing patterns.

Use recursive approach checking if nodes are in left or right subtree. Time O(n), space O(h) for recursion stack. Discuss optimization for BST case and handling when one node is ancestor of other.

Structure around cost reduction levers (route optimization, fleet efficiency, fuel hedging) and revenue enhancement (pricing, service mix, new markets). KPMG values practical, data-driven recommendations — show how you would quantify the impact of each lever.

This directly tests KPMG's core value. Choose a genuine ethical challenge where you prioritized doing the right thing. Show your reasoning process and how you handled potential consequences of your decision.

Structure around market selection, entry mode (organic, JV, acquisition), regulatory and tax considerations, and organizational readiness. KPMG has deep expertise in cross-border advisory — show awareness of the complexity of international expansion.

This tests KPMG's "Together" value. Show how you contributed to the team's success beyond your individual responsibilities. Demonstrate awareness of team dynamics and how you supported others' contributions.

Consider customer experience, mobile and online platform capabilities, data analytics, cybersecurity, and regulatory compliance. KPMG values structured prioritization — create a framework for ranking initiatives by impact and feasibility.

Show your communication skills and emotional intelligence. Demonstrate how you prepared for the conversation, delivered the message with empathy and clarity, and managed the aftermath constructively.

Segment by client type (public companies, private companies, government entities, nonprofits), average audit fees by size, and regulatory requirements driving demand. Show awareness of Big Four market share and industry dynamics.

KPMG has a strong private enterprise practice. Consider governance structures, succession planning, tax implications, professionalization of management, and family dynamics. Balance business optimization with family relationship preservation.

Reference specific KPMG practices, thought leadership, or cultural elements that resonate with you. Show you understand how KPMG differentiates within the Big Four and how your goals align with their strengths and strategy.

Show your learning agility and ability to perform under pressure. KPMG's "Excellence" value means demonstrating high standards even when learning on the fly. Emphasize both the speed of learning and the quality of execution.