Wells Fargo Software Engineer
Interview Guide

• Implement an LRU cache with a hash map plus a doubly linked list, and test eviction order, updating an existing key, and capacity 1
• Implement a queue with two stacks and explain why each element moves at most once, which makes the operations amortised O(1)
• Count inversions in an array during merge sort in O(n log n), and check the result against a brute-force O(n^2) count on random inputs

Deliverable: Three working solutions with complexity notes, and a list of the edge cases each one was tested against.

• Count all palindromic subsequences of a string with interval DP in O(n^2), after asking whether identical subsequences at different positions count separately
• Write a short explanation of HashMap collision handling (bucket chaining, treeified buckets, resizing) and the equals/hashCode contract for a custom key, including what breaks if the key is mutated after insertion
• Solve two problems in HackerRank's editor, reading stdin and matching the exact output format, and comment each non-obvious step before submitting

Deliverable: A tested palindromic-subsequence solution, a HashMap explanation you could give out loud, and two submissions a reviewer could read cold.

• Explain the four OOP principles, each tied to a class or module from a real project, and write a thread-safe singleton, stating why the approach you chose is safe
• Explain garbage collection (GC roots, reachability, generations) and the JVM memory areas, then contrast multithreading with asynchronous code and name one race condition and its fix
• Build a small Spring Boot service with POST, PUT and GET endpoints and constructor injection, and write one test that swaps in a fake dependency
• Practise the Java Streams and Kafka consumer/partition topics from the question bank

Deliverable: A working Spring Boot service with a test that uses a fake dependency, plus short explanations of GC, concurrency and the four OOP principles.

• Write a transaction-history query with multiple joins, a subquery and a window function, then state where the window function is evaluated relative to WHERE and LIMIT
• Work through the worked SQL exercise on composite indexes and sort elimination, then do the window-function drill on version gaps and running totals
• Explain ACID with one concrete failure per property, and normalization versus denormalization with a case where each is the right call
• Describe an ETL pipeline with data-quality checks, and how you would protect sensitive customer data with encryption at rest and access controls

Deliverable: Two hand-written SQL queries with their evaluation order explained, and one-paragraph answers on ACID, normalization and pipeline governance.

• Design a payment system that stays consistent through failover: an idempotent write API, an outbox or saga across services, and reconciliation
• Design a rate limiter for public-facing banking APIs, choosing the algorithm, the counter store, the limiting key and the rejected-request response
• Explain asynchronous service communication through Kafka: partitions, consumer groups, at-least-once delivery and how the receiver deduplicates
• Work the worked design exercise on replication lag, then sketch cursor pagination for a large dataset

Deliverable: Two design sketches (payments, rate limiter), each listing the failure it handles and the trade-off it accepts.

• Outline a phased migration of an on-premises application to Azure: run old and new paths side by side, compare their outputs, keep a rollback path, and secure the data while it moves
• Explain TLS at the level of the handshake, certificates and what it does and does not protect, and explain CI/CD in terms of the risk it removes from deployment
• Work the debugging drill on the sixty-second latency sawtooth, then write the ordered checks you would run for a slow production response
• Optionally, work the coding exercise on merging partitioned event streams to practise ordering reasoning in messaging systems

Deliverable: A one-page migration plan with a rollback step, and a written ordered checklist for diagnosing slow production responses.

• Write four or five STAR stories covering a technical conflict, a challenging project and how you measured success, a tight deadline with unclear requirements, code-review feedback, and getting unblocked without help from your tech lead
• Prepare a specific answer to why you want to work at Wells Fargo rather than a technology-first company, tied to the kind of work described for the role
• Run a mock day of back-to-back sessions (one coding, one design, one behavioral) and check that your project facts stay the same across all three
• Write down the facts that must not change between tellings: team size, timeline, your role, the result

Deliverable: A one-page story sheet with fixed facts per story, and notes from a mock back-to-back session.