Top 30 Most Common Amazon It App Dev Engr Ii Interview Question You Should Prepare For
Written by
James Miller, Career Coach
Preparing for an amazon it app dev engr ii interview question requires a deep understanding of technical concepts, problem-solving skills, and an ability to articulate past experiences aligning with Amazon's culture. The role of an IT App Dev Engr II at Amazon is crucial, involving the design, development, and maintenance of robust, scalable, and efficient applications that support Amazon's vast infrastructure and business operations. These roles demand proficiency in data structures, algorithms, system design, and practical application development knowledge, often within distributed systems environments. Success in the amazon it app dev engr ii interview question process hinges on demonstrating strong coding skills, proposing thoughtful system designs, and providing clear, data-driven examples that showcase leadership principles. Many candidates find the structured nature of Amazon interviews challenging but navigable with focused preparation. Understanding the typical questions asked in an amazon it app dev engr ii interview question allows you to structure your study and practice effectively, boosting confidence and performance on interview day. This guide compiles 30 common questions to help you refine your skills and approach the amazon it app dev engr ii interview question with readiness.
What Are amazon it app dev engr ii interview question?
Amazon IT App Dev Engr II interview questions cover a wide range of topics essential for a mid-level software development engineer. They are designed to assess your technical depth, problem-solving capabilities, and cultural fit within Amazon's unique environment. The core areas typically include data structures and algorithms (coding interviews), system design (both high-level and low-level), and behavioral questions based on Amazon's 16 Leadership Principles. Coding questions test your ability to write efficient, correct code under pressure, often focusing on common problems involving arrays, strings, trees, graphs, and dynamic programming. System design questions evaluate how you approach building scalable, reliable, and maintainable software systems. Behavioral questions are critical for assessing past performance and predicting future behavior, specifically looking for examples where you demonstrated leadership principles like Ownership, Bias for Action, and Dive Deep. Mastering these areas is key to succeeding in the amazon it app dev engr ii interview question.
Why Do Interviewers Ask amazon it app dev engr ii interview question?
Interviewers ask amazon it app dev engr ii interview question to evaluate a candidate's technical proficiency and alignment with Amazon's operational philosophy. Coding questions verify foundational computer science knowledge and coding skills, ensuring the candidate can write functional and efficient code, a core requirement for any IT App Dev Engr II. System design questions assess the candidate's ability to think at a higher level, designing systems that are scalable, resilient, and cost-effective—essential skills for building applications that support Amazon's global operations. Behavioral questions, framed around the Leadership Principles, gauge how candidates have handled real-world situations, looking for evidence of problem-solving, teamwork, customer obsession, and accountability. The combination of these question types in an amazon it app dev engr ii interview question provides a holistic view of the candidate's capabilities, helping interviewers determine if they have the technical skills and the right mindset to thrive and contribute effectively in an Amazon IT App Dev team.
Preview List
Implement a valid BST check.
Find the lowest common ancestor in a binary tree.
Detect a cycle in a directed graph.
Find the shortest path in an unweighted graph.
Implement linked list reversal.
Merge two sorted linked lists.
Find the largest sum subarray.
Implement an LRU cache.
Implement string matching (KMP).
Validate balanced parentheses.
Design a URL shortening service.
Design a parking lot system.
Design an online book store.
Design a messaging queue.
Design a global file storage system.
Tell me about a complex software problem you solved.
How do you ensure your code is maintainable?
Describe taking ownership of a critical task.
Give an example of using data for a decision.
Describe a time you failed and what you learned.
Explain polymorphism and its use.
What are your favorite data structures and why?
How do you optimize application performance?
Explain handling concurrency.
What’s your approach to testing and debugging?
How do you stay current with tech trends?
Design a thread-safe singleton.
Write code to serialize/deserialize a binary tree.
How do you prioritize tasks?
Discuss influencing others without authority.
1. Implement a valid BST check.
Why you might get asked this:
Tests understanding of tree properties and traversal algorithms, fundamental for data structure proficiency needed for an amazon it app dev engr ii interview question.
How to answer:
Explain the recursive approach using min/max bounds passed during traversal or the in-order traversal method verifying ascending order.
Example answer:
To check for a valid BST, I'd use a recursive helper function isValid(node, minval, maxval). For each node, check minval < node.val < maxval. The initial call would be isValid(root, -infinity, +infinity).
2. Find the lowest common ancestor in a binary tree.
Why you might get asked this:
Evaluates tree traversal skills and the ability to handle recursive logic for finding relationships between nodes, common in amazon it app dev engr ii interview question scenarios.
How to answer:
Describe a recursive post-order traversal approach where the function returns the node if it's one of the targets or if LCA is found in subtrees.
Example answer:
I'd use recursion. If the current node is p or q, return it. Recursively call on left and right children. If both return non-null nodes, the current node is the LCA. Otherwise, return whichever child call returned a non-null node.
3. Detect a cycle in a directed graph.
Why you might get asked this:
Crucial for understanding graph algorithms and their applications in dependency management or state transitions, relevant for an amazon it app dev engr ii interview question.
How to answer:
Explain using DFS with three sets: visited, visiting (recursion stack), and unvisited nodes. A back edge to a node in the 'visiting' set indicates a cycle.
Example answer:
I would use DFS. Maintain three sets: visited (fully processed), recursionstack (currently processing), and unvisited. For a node, mark as visiting, then recurse. If a neighbor is in recursionstack, a cycle exists. Mark as visited after processing children.
4. Find the shortest path in an unweighted graph.
Why you might get asked this:
Assesses basic graph traversal and pathfinding algorithms, vital for understanding network routing or dependency resolution in systems relevant to an amazon it app dev engr ii interview question.
How to answer:
Explain using Breadth-First Search (BFS), starting from the source and exploring layer by layer until the destination is reached.
Example answer:
BFS is ideal for unweighted graphs. Start a queue with the source node. Maintain a distance map and parent pointers. Explore neighbors level by level, adding them to the queue if unvisited. Stop when the destination is dequeued; the path is reconstructible via parent pointers.
5. Implement linked list reversal.
Why you might get asked this:
A fundamental data structure manipulation problem, testing basic pointer handling and iterative/recursive thinking, often appearing in amazon it app dev engr ii interview question coding rounds.
How to answer:
Describe the iterative approach using three pointers (prev, current, next) or a recursive approach.
Example answer:
For iterative reversal: Use prev = null, current = head. Loop while current is not null. Store current.next in nexttemp. Set current.next = prev. Update prev = current, current = nexttemp. Return prev.
6. Merge two sorted linked lists.
Why you might get asked this:
Tests pointer manipulation, handling edge cases, and merging sorted sequences, a common pattern in coding problems relevant to an amazon it app dev engr ii interview question.
How to answer:
Explain using a dummy head node and a pointer to build the merged list by comparing nodes from both input lists.
Example answer:
Use a dummy head node and a tail pointer initialized to the dummy. Iterate while both lists have nodes, appending the smaller node to the tail and advancing that list's pointer. Append any remaining nodes. Return dummy.next.
7. Find the largest sum subarray (Kadane’s algorithm).
Why you might get asked this:
A classic dynamic programming problem assessing optimization and greedy approach, often used to gauge problem-solving efficiency in an amazon it app dev engr ii interview question.
How to answer:
Describe Kadane's algorithm: iterate through the array, keeping track of the maximum sum ending at the current position and the overall maximum sum found so far.
Example answer:
Initialize maxsofar = array[0] and currentmax = array[0]. Iterate from the second element: currentmax = max(array[i], currentmax + array[i]). maxsofar = max(maxsofar, currentmax).
8. Implement an LRU (Least Recently Used) cache.
Why you might get asked this:
Evaluates knowledge of data structures (hashmap and doubly linked list) and their combination for efficient O(1) operations, crucial for performance-sensitive applications relevant to an amazon it app dev engr ii interview question.
How to answer:
Explain using a hashmap to store key-node pairs and a doubly linked list to maintain the order of usage, moving recently accessed items to the front and removing the least recently used from the back.
Example answer:
Combine a HashMap and a DoublyLinkedList. Node stores key/value and list pointers. get(key) returns value from map, moves node to front of list. put(key, value) adds/updates map entry, moves node to front. If capacity exceeded, remove tail from list/map.
9. Implement string matching (KMP algorithm).
Why you might get asked this:
Tests understanding of advanced string algorithms and pattern matching, demonstrating an ability to solve complex string problems efficiently, relevant for an amazon it app dev engr ii interview question.
How to answer:
Describe the KMP algorithm: build a Longest Proper Prefix Suffix (LPS) array for the pattern, then use it to avoid redundant comparisons during matching.
Example answer:
First, compute the LPS array for the pattern. This array helps determine where to resume the search in the text after a mismatch. Then, iterate through the text, using the LPS array to efficiently shift the pattern when characters don't match.
10. Validate if a string has balanced parentheses.
Why you might get asked this:
A classic stack problem assessing understanding of stack data structure and its application in parsing or validating structured data, often seen in amazon it app dev engr ii interview question screening.
How to answer:
Explain using a stack: push opening braces onto the stack. When a closing brace is encountered, pop from the stack and check if it's the matching opening brace.
Example answer:
Use a stack. Map closing braces to their opening counterparts. Iterate through the string: if character is opening, push onto stack. If closing, check if stack is empty or top doesn't match; if so, invalid. Pop and continue. Stack must be empty at the end for valid.
11. Design a URL shortening service (like bit.ly).
Why you might get asked this:
A common system design problem evaluating scalability, storage, encoding/decoding strategies, and handling high read/write traffic, essential for an amazon it app dev engr ii interview question design round.
How to answer:
Discuss unique ID generation (base-62 encoding), database schema (mapping short code to long URL), handling collisions, scalability concerns (caching, load balancing), and redirects.
Example answer:
Use base-62 encoding for short codes. Store mapping in a database (e.g., NoSQL for scale). Need collision resolution (retry ID generation). Implement 301 redirect. Consider caching hot URLs and rate limiting. Scale read traffic via replicas, write traffic with partitioning.
12. Design a parking lot system.
Why you might get asked this:
Tests object-oriented design principles, managing state, and handling different types/constraints, showcasing practical design skills for an amazon it app dev engr ii interview question.
How to answer:
Focus on object modeling (ParkingLot, Levels, Spots, Vehicle, Ticket), data structures for managing available spots (e.g., lists, hashmaps per level/type), and key operations (park vehicle, leave spot, generate ticket).
Example answer:
Objects: ParkingLot, Level, Spot (different types: compact, large, etc.), Vehicle (car, truck, motorcycle), ParkingTicket. ParkingLot manages Levels. Level manages Spots. Use maps or arrays to quickly find available spots per type on each level.
13. Design an online book store or e-commerce system.
Why you might get asked this:
Evaluates understanding of complex multi-component systems (user management, catalog, inventory, orders, payments), crucial for an amazon it app dev engr ii interview question focused on large-scale applications.
How to answer:
Break down into key components: User Service, Product Catalog, Inventory Service, Order Service, Payment Service, Search Service, Recommendation Service. Discuss data models, APIs, and interactions.
Example answer:
Components: User (auth, profile), Catalog (products, categories), Inventory (stock levels), Cart, Order (placement, status), Payment Gateway integration, Search, Recommendations. Database could be relational for core transactions, NoSQL for catalog/user data. Microservices architecture.
14. Design a messaging queue system.
Why you might get asked this:
Tests understanding of distributed systems patterns, asynchronous communication, reliability, and fault tolerance, highly relevant for an amazon it app dev engr ii interview question involving distributed application design.
How to answer:
Discuss producers, consumers, queue structure (persistent/in-memory), message delivery guarantees (at-least-once, at-most-once, exactly-once), scaling, and acknowledgment mechanisms.
Example answer:
Components: Producer, Broker (queue), Consumer. Broker stores messages. Consumers pull/receive messages. Need persistence for reliability. Acknowledgment ensures message processing. Scaling involves multiple brokers/partitions and consumer groups. Discuss delivery semantics.
15. Design a global file storage system (like Dropbox).
Why you might get asked this:
A complex system design problem covering data replication, consistency models, synchronization, metadata management, and handling scale/availability, a common high-level design challenge in amazon it app dev engr ii interview question.
How to answer:
Discuss file metadata storage (consistent database), data storage (distributed object store), data replication strategies, consistency models (eventual consistency is common), client synchronization logic, and conflict resolution.
Example answer:
Store metadata (filenames, versions, permissions) in a globally consistent database. Store file chunks in a distributed object store (like S3). Use replication across regions. Client synchronizes by comparing local and remote metadata, uploading/downloading changes. Handle conflicts (e.g., last writer wins).
16. Tell me about a time you handled a complex software problem.
Why you might get asked this:
Tests problem-solving skills, debugging approach, and ability to break down complexity, directly assessing the "Dive Deep" and "Problem Solving" aspects relevant to an amazon it app dev engr ii interview question.
How to answer:
Use the STAR method: Situation, Task, Action, Result. Describe the problem, why it was complex, your step-by-step process to understand and solve it, and the positive outcome.
Example answer:
S: We had a production service outage with no clear cause, impacting users. T: I needed to quickly identify and fix the root cause under pressure. A: I dove into logs, metrics, and recent code changes, isolating the issue to a specific data race condition introduced recently. I developed and deployed a hotfix. R: The service was restored within the hour, and I later implemented a long-term fix and added monitoring.
17. How do you ensure your code is maintainable?
Why you might get asked this:
Evaluates coding practices and commitment to quality, essential for working in a large codebase environment like Amazon, relevant to an amazon it app dev engr ii interview question standard.
How to answer:
Discuss clean code principles (readability, clear names, small functions), documentation, unit testing, following coding standards, and participation in code reviews.
Example answer:
I focus on readability with clear variable/function names and comments where necessary. I write modular code with single responsibilities. I adhere to team coding standards, write unit tests for critical logic, and actively participate in code reviews to catch issues early and share knowledge.
18. Describe a situation where you had to take ownership of a critical task.
Why you might get asked this:
Directly assesses the "Ownership" leadership principle, looking for initiative, accountability, and commitment to seeing tasks through to completion, key for an amazon it app dev engr ii interview question.
How to answer:
Use STAR. Explain a situation where a critical task lacked a clear owner or was at risk, how you stepped up, what actions you took, and the positive result.
Example answer:
S: A key deadline was approaching for a feature, but a critical component wasn't progressing as planned due to resource constraints. T: The project was at risk. I decided I needed to step up. A: I took ownership of the component, worked extra hours, collaborated closely with dependencies, and proactively communicated status and roadblocks to the team. R: The component was completed on time, and the feature launched successfully.
19. Give an example of how you used data to make a decision.
Why you might get asked this:
Tests analytical skills and data-driven decision making, aligning with Amazon's culture of using metrics, important for an amazon it app dev engr ii interview question.
How to answer:
Use STAR. Describe a situation where a decision was needed, how you gathered and analyzed relevant data (metrics, logs, user feedback), and how that data informed your choice and the outcome.
Example answer:
S: Users reported slow load times on a specific application page. T: We needed to decide which area to optimize first for maximum impact. A: I analyzed performance metrics from our monitoring tools, looking at response times for different backend endpoints and frontend rendering times. This data showed a particular API call was the bottleneck. R: We focused optimization efforts on that API, resulting in a 40% reduction in page load time and positive user feedback.
20. Describe a time you failed and what you learned from it.
Why you might get asked this:
Evaluates self-awareness, resilience, and ability to learn from mistakes, crucial traits for continuous improvement at Amazon, a common behavioral question in an amazon it app dev engr ii interview question.
How to answer:
Be honest about a genuine failure (technical or project-related), take responsibility, focus on the lessons learned, and explain how you applied those lessons to future situations.
Example answer:
S: I underestimated the complexity of integrating a new third-party library into our system. T: The integration took much longer than planned, delaying the project. A: I didn't do adequate upfront research on the library's nuances and dependencies. R: I learned the importance of thorough technical investigation and prototyping before committing to timelines, and now allocate specific spikes for evaluating new technologies before integrating them fully.
21. Explain polymorphism and how you have used it.
Why you might get asked this:
Tests fundamental object-oriented programming concepts, essential for building flexible and extensible software systems, standard for an amazon it app dev engr ii interview question.
How to answer:
Define polymorphism (method overriding and overloading). Provide concrete examples from your past projects where you used inheritance or interfaces to achieve polymorphism.
Example answer:
Polymorphism means "many forms". In OOP, it allows objects of different classes to be treated as objects of a common superclass or interface. I used it when processing different types of payment methods (credit card, PayPal). Each method implemented a PaymentProcessor interface with a processPayment() method, allowing me to process any type of payment using a single function call on the interface object.
22. What are your favorite data structures and why?
Why you might get asked this:
Gauges your understanding of data structure strengths/weaknesses and their practical application in solving problems, key knowledge for an amazon it app dev engr ii interview question.
How to answer:
Mention a few data structures (e.g., Hashmap, Tree, Graph, Queue) and explain specific real-world problems or scenarios where they are particularly effective.
Example answer:
I find HashMaps incredibly useful due to their average O(1) time complexity for lookups, insertions, and deletions, great for caches or frequency counts. Graphs are powerful for modeling relationships, which I've used for social networks and dependency tracking. Trees are versatile, especially Binary Search Trees for ordered data or tries for string prefixes.
23. How do you optimize the performance of a slow-running application?
Why you might get asked this:
Assesses practical debugging, profiling, and optimization skills, crucial for an IT App Dev Engr II dealing with performance-sensitive applications at scale, relevant to an amazon it app dev engr ii interview question.
How to answer:
Describe a systematic approach: identify the bottleneck using profiling tools, analyze the code/system contributing to the bottleneck, propose solutions (algorithmic, data structure, caching, scaling), implement, and measure the impact.
Example answer:
First, I'd use profiling tools (e.g., JProfiler, built-in browser dev tools) to pinpoint the slowest parts – CPU, memory, I/O, database calls. Then, I'd analyze the specific code paths or queries identified. Optimization strategies might include algorithmic improvements, choosing better data structures, adding caching layers, optimizing database queries/indexing, or horizontal scaling if it's a throughput issue. Finally, measure again to confirm improvement.
24. Explain handling concurrency in your programs.
Why you might get asked this:
Essential knowledge for building multi-threaded or distributed applications without introducing race conditions or deadlocks, frequently tested in an amazon it app dev engr ii interview question.
How to answer:
Discuss understanding critical sections, using synchronization primitives (locks, mutexes, semaphores), using thread-safe data structures, and being mindful of potential issues like deadlocks or livelocks.
Example answer:
I handle concurrency by identifying critical sections that modify shared resources. I use synchronization primitives like locks or mutexes to ensure only one thread accesses the critical section at a time. I also prefer using built-in thread-safe collections provided by the language/framework where possible. For complex scenarios, I analyze for potential deadlocks or race conditions during design and code review phases.
25. What’s your approach to testing and debugging?
Why you might get asked this:
Tests quality mindset and systematic problem-solving skills, vital for building reliable software, a standard part of an amazon it app dev engr ii interview question.
How to answer:
Describe your testing strategy (unit, integration, system tests), use of testing frameworks, how you approach reproducing bugs, using debugging tools, and logging.
Example answer:
My approach starts with writing unit tests for core logic using frameworks like JUnit or NUnit. I follow up with integration tests to ensure components work together and system tests for end-to-end flows. For debugging, I first try to reliably reproduce the issue. Then I use debugging tools (IDE debugger, print statements, logging) to inspect state and execution flow, narrow down the cause, and apply a fix. Comprehensive logging is key for production issues.
26. How do you stay current with technology trends?
Why you might get asked this:
Evaluates curiosity, commitment to continuous learning, and adaptability, important traits for an engineer in a fast-evolving tech environment like Amazon, relevant for an amazon it app dev engr ii interview question.
How to answer:
Mention specific methods you use: reading blogs/articles, following industry leaders, taking online courses, experimenting with new technologies, attending conferences/webinars, or contributing to open source.
Example answer:
I make it a habit to read tech blogs and news sites like InfoQ, Hacker News, and specific language/framework blogs. I follow key people on social media. I also set aside time for online courses on platforms like Coursera or Udemy for deeper dives into new areas. Sometimes I'll prototype small projects with a new technology to understand it hands-on.
27. Describe how you would design a thread-safe singleton pattern.
Why you might get asked this:
Tests understanding of design patterns and concurrent programming challenges, a common application of synchronization concepts in an amazon it app dev engr ii interview question.
How to answer:
Explain approaches like using double-checked locking, a static inner class (Initialization-on-demand holder idiom), or using an Enum (simplest and often preferred).
Example answer:
A simple, thread-safe way is the Initialization-on-demand holder idiom using a static inner class. The instance isn't created until getInstance() is first called, and class loading handles synchronization. Alternatively, the Enum approach is concise and guaranteed to be thread-safe by the JVM. Double-checked locking requires careful implementation with volatile keywords.
28. Write code to serialize and deserialize a binary tree.
Why you might get asked this:
Tests understanding of tree traversal and converting a data structure to a format for storage/transmission and back, a practical coding problem for an amazon it app dev engr ii interview question.
How to answer:
Explain using a pre-order traversal (or BFS) to serialize, marking null nodes explicitly. Deserialization rebuilds the tree recursively or iteratively from the serialized string/list.
Example answer:
For serialization, I'd use pre-order traversal (Root, Left, Right), storing node values in a list, adding a special marker (like '#') for null children. E.g., [1, 2, #, #, 3, 4, #, #, 5, #, #]. For deserialization, iterate through this list, creating nodes recursively, using the marker to identify nulls and stop recursion.
29. How do you prioritize tasks in a project?
Why you might get asked this:
Evaluates project management skills, ability to manage workload, and alignment with team/business goals, relevant for an amazon it app dev engr ii interview question assessing organizational fit.
How to answer:
Discuss considering factors like impact, urgency, dependencies, effort required, and aligning with team goals or product roadmap. Mention communication with stakeholders or team lead.
Example answer:
I prioritize based on a few factors: impact (how much value does it deliver?), urgency (does it have a strict deadline or is it blocking others?), dependencies (is it needed for other tasks?), and effort. I align my priorities with the overall project goals and discuss with my lead or product manager if there are conflicts or ambiguities to ensure alignment.
30. Discuss a time when you had to influence others without authority.
Why you might get asked this:
Directly assesses the "Earn Trust" and "Influence" leadership principles, looking for collaboration, communication, and persuasion skills, key for senior roles in an amazon it app dev engr ii interview question.
How to answer:
Use STAR. Describe a situation where you needed people from other teams or higher levels to adopt an idea or change course, how you built trust, used data/logic to persuade, and the outcome.
Example answer:
S: I believed a change in our team's API contract would significantly improve integration for downstream teams, but they were hesitant due to perceived effort. T: I needed to influence them to adopt the change without being their manager. A: I prepared a detailed proposal outlining the long-term benefits (reduced maintenance, fewer bugs) with data supporting the effort reduction after the initial change. I held meetings to patiently explain the rationale and address their concerns directly. R: They eventually agreed, and the improved API indeed streamlined future integrations.
Other Tips to Prepare for a amazon it app dev engr ii interview question
Thorough preparation is paramount for any amazon it app dev engr ii interview question. Beyond mastering the technical topics and practicing coding problems, take time to deeply understand Amazon's 16 Leadership Principles. For each principle, prepare several specific examples from your past experiences using the STAR method. Don't just memorize answers; understand the underlying principles and be ready to adapt your stories to different questions. Practice explaining your technical solutions clearly and concisely, as communication is key. As famously said, "By failing to prepare, you are preparing to fail." This is especially true for a rigorous process like the amazon it app dev engr ii interview question. Consider mock interviews to simulate the real experience and get constructive feedback. Tools like Verve AI Interview Copilot can be invaluable for practicing behavioral questions, providing instant feedback on your STAR responses and alignment with principles. Utilizing Verve AI Interview Copilot helps refine your delivery and content, making sure your stories highlight the right aspects. Remember, confidence comes from preparation. Leveraging resources such as Verve AI Interview Copilot (https://vervecopilot.com) to practice your responses can significantly boost your readiness for the behavioral portion of the amazon it app dev engr ii interview question.
Frequently Asked Questions
Q1: How long is an Amazon IT App Dev Engr II interview process?
A1: Typically involves recruiter calls, 1-2 online assessments, and a full loop of 4-6 interviews.
Q2: What coding languages are best for the amazon it app dev engr ii interview question?
A2: Java, C++, Python, or C# are common; choose the one you are most proficient in.
Q3: Should I study all 16 Leadership Principles for the amazon it app dev engr ii interview question?
A3: Yes, prepare examples for all 16 as any could be asked, though some are more common.
Q4: How deep should system design answers be for amazon it app dev engr ii interview question?
A4: You need to cover key components, data flow, storage, scalability, and trade-offs reasonably well in ~45 minutes.
Q5: Is the Bar Raiser interview different in an amazon it app dev engr ii interview question?
A5: Yes, the Bar Raiser focuses heavily on Leadership Principles and overall hiring standards, often asking probing follow-up questions.
