Visa Software Engineer
Interview Guide

• Sit a timed set of three to four problems in a plain browser editor, matching the easy-to-medium-hard mix candidates report. Include longest substring without repeating characters, the start node of a linked-list cycle, and one dynamic programming problem.
• Solve the problems from easiest to hardest and log the minutes spent on each.
• Before each submission, run the prompt's examples plus an empty input, a single element and a maximum-size input through a harness.

Deliverable: A timing log for each problem and a list of every edge case your first submissions missed.

• Implement the reported LRU cache with a hash map and a doubly linked list with sentinel nodes, and state why get and put are O(1).
• Implement the reported structure that increments and decrements string counts and returns the max and min keys in O(1), using a linked list of count buckets. Write down the invariant that keeps both ends correct.
• Implement longest increasing subsequence in O(n log n) and explain why the tails array stays sorted.
• Work through the coding exercise on as-of balance queries over an append-only log, and compare the cost of the naive approach with the offline sweep.

Deliverable: Three implementations written without references, each with its invariant in one sentence, plus the written cost comparison for the balance exercise.

• Write the reported top-three-salaries-per-department query twice, once with ROW_NUMBER and once with DENSE_RANK, and show on sample data how each handles ties.
• Explain inner versus outer joins on a two-table example that includes unmatched rows.
• Work through the SQL exercise on versioning a loan schedule and run its checks.
• Answer the idempotent charge endpoint drill: the unique constraint, the ON CONFLICT claim, and what a concurrent loser returns.

Deliverable: Two ranking queries with a tie case that separates them, and a passing run of the loan-schedule checks.

• Write two-sentence answers with one example each on JVM memory areas, garbage collection, interface versus abstract class, and one SOLID principle applied to real code.
• Explain concurrency versus asynchrony, a race condition you could reproduce, and two ways to prevent deadlock, such as a global lock order and lock timeouts.
• Walk through what happens when you enter a URL, from DNS through the TCP handshake to the HTTP response, then cover OAuth and JWT basics and what Docker and Kubernetes each manage.
• Work through the duplicate-captures debugging drill and explain why checking first and then inserting lets two requests reach the processor.

Deliverable: A one-page fundamentals card with a two-sentence answer for each topic, readable aloud without notes.

• Design the reported payment gateway API: endpoints, the idempotency header, the stored response, where the rate limiter sits, and where caching is safe.
• Model a payment as explicit states, and say what a retry does in each state and what happens if the process dies after calling the processor.
• Work through the webhook-intake design exercise from start to finish, then redo it with Kafka as the transport, stating the partition key and the deduplication key.
• If your loop is entry-level, also prepare a schema walkthrough of one past project.

Deliverable: One annotated design covering the API contract, states, idempotency, and failure handling for the ledger-down case.

• Write a one-page fact sheet for your main project: traffic, data size, team size, timeline, what broke and which decisions were yours.
• Prepare STAR answers for the reported prompts: a complex project walkthrough, a tight deadline or changing requirements, a technical disagreement, code quality under timelines, and why Visa.
• Rehearse the incident-postmortem drill with a timeline, how you sized the damage and the prevention change, including one thing you got wrong.
• Run a mock phone screen where a coding problem switches to a fundamentals question partway through.

Deliverable: A project fact sheet and five STAR answers, each ending in a measured result or an honest statement that nothing was measured.

• Run mock rounds back to back: one coding problem from the reported DSA list, one design prompt (a distributed scheduler, or an event-driven pipeline that ingests transaction events), and one behavioral round.
• Afterwards, compare the project figures you quoted in each round against your fact sheet and correct any that changed.
• Redo the single problem from days 1 to 6 that you missed most badly, from a blank file.

Deliverable: A list of the remaining weak spots from the mock, each with the first thing you will say if it comes up.