Senior Python Software Engineer Technical Interview Challenge Set Challenge 1: Distributed API Request Rate Limiter Problem Statement Design and implement a rate limiter that controls the number of API requests a user can make within a specific time window. Real-World Engineering Context Large-scale backend systems use rate limiters to prevent abuse, protect infrastructure, and ensure fair resource allocation among users. Input User ID Request timestamp Maximum allowed requests Time window duration Output Return whether the request should be accepted or rejected. Constraints Handle millions of requests efficiently. Support multiple users simultaneously. Maintain low memory consumption. Edge Cases First request from a user. Multiple requests arriving at the same timestamp. Expired request history. Extremely high traffic volume. Expected Reasoning Approach Use a sliding window approach with efficient storage of request timestamps. Optimized Solution Strategy Use a dictionary where each user maps to a queue of recent request timestamps. Remove expired timestamps before checking the request limit. Python Solution from collections import defaultdict, deque import time class RateLimiter: def __init__(self, limit, window): self.limit = limit self.window = window self.requests = defaultdict(deque) def allow_request(self, user_id, timestamp): queue = self.requests[user_id] while queue and timestamp - queue[0] >= self.window: queue.popleft() if len(queue) < self.limit: queue.append(timestamp) return True return False limiter = RateLimiter(3, 60) print(limiter.allow_request("user1", 10)) print(limiter.allow_request("user1", 20)) print(limiter.allow_request("user1", 30)) print(limiter.allow_request("user1", 40)) Code Walkthrough defaultdict(deque) stores request history efficiently. Old timestamps are removed before validation. The request is approved only when the user has available capacity. Complexity Analysis Time Complexity: O(n) in worst case when cleaning timestamps Space Complexity: O(u × r) where: u = number of users r = stored requests per user Alternative Approach Use token bucket algorithms for smoother traffic handling. Common Mistakes Using lists instead of queues. Not removing expired timestamps. Ignoring concurrent requests. Interview Evaluation Criteria Strong candidates should explain: Scalability considerations. Data structure selection. Real production limitations. --- Challenge 2: Detect Duplicate Transactions in Payment Processing Problem Statement Given a stream of financial transactions, identify duplicate transactions based on transaction ID and timestamp rules. Real-World Engineering Context Payment platforms must detect duplicate payments caused by retries, network failures, or system errors. Input A list of transactions containing: Transaction ID User ID Amount Timestamp Output Return duplicate transactions. Constraints Handle large transaction volumes. Optimize lookup speed. Edge Cases Same ID with different users. Same transaction after a long delay. Missing transaction fields. Expected Reasoning Approach Use hashing for constant-time duplicate detection. Python Solution def find_duplicates(transactions): seen = set() duplicates = [] for transaction in transactions: key = ( transaction["id"], transaction["timestamp"] ) if key in seen: duplicates.append(transaction) else: seen.add(key) return duplicates transactions = [ {"id":1,"timestamp":100}, {"id":2,"timestamp":200}, {"id":1,"timestamp":100} ] print(find_duplicates(transactions)) Complexity Analysis Time Complexity: O(n) Space Complexity: O(n) Alternative Approach Use database indexing for distributed systems. Common Mistakes Comparing entire objects unnecessarily. Using nested loops. Ignoring scalability. Interview Evaluation Criteria Candidates should demonstrate: Hash table knowledge. Backend system awareness. Performance optimization thinking. --- Challenge 3: Build an Efficient Search Autocomplete System Problem Statement Create an autocomplete engine that suggests the most relevant search terms as users type. Engineering Context Search engines, e-commerce platforms, and developer tools use autocomplete systems to improve user experience. Expected Concepts Trie data structures Ranking algorithms Search optimization Python Solution class TrieNode: def __init__(self): self.children = {} self.words = [] class Autocomplete: def __init__(self): self.root = TrieNode() def insert(self, word): node = self.root for char in word: node = node.children.setdefault(char, TrieNode()) node.words.append(word) def search(self, prefix): node = self.root for char in prefix: if char not in node.children: return [] node = node.children[char] return node.words[:5] engine = Autocomplete() for word in ["python", "programming", "product"]: engine.insert(word) print(engine.search("pro")) Complexity Analysis Insertion: Time: O(k) Search: Time: O(k) Space: O(nk) --- Challenge 4: Backend Task Scheduling System Problem Statement Design a task scheduler that executes jobs based on priority and deadlines. Key Concepts Heap data structure Priority queues Backend processing Python Solution import heapq class Scheduler: def __init__(self): self.tasks = [] def add_task(self, priority, task): heapq.heappush( self.tasks, (priority, task) ) def execute(self): while self.tasks: priority, task = heapq.heappop(self.tasks) print(task) scheduler = Scheduler() scheduler.add_task(1,"Send Email") scheduler.add_task(0,"Database Backup") scheduler.execute() Complexity Analysis Insert: O(log n) Execution: O(n log n) --- Challenge 5: Design a URL Shortener System Problem Statement Create a service that converts long URLs into short unique identifiers. Engineering Context Used by social networks, marketing platforms, and analytics systems. Concepts Tested Hashing Encoding Database design Python Solution import random import string class URLShortener: def __init__(self): self.database = {} def shorten(self, url): code = ''.join( random.choice(string.ascii_letters) for _ in range(6) ) self.database[code] = url return code def retrieve(self, code): return self.database.get(code) Complexity Analysis Shortening: O(1) Retrieval: O(1) --- Remaining Advanced Interview Challenges Challenge 6: Distributed Cache Implementation Focus: LRU Cache Memory management Performance optimization Challenge 7: Database Query Optimization Engine Focus: Indexing Query planning Backend architecture Challenge 8: Real-Time Notification Delivery System Focus: Queues Event-driven architecture Scalability Challenge 9: Log Processing and Analytics Pipeline Focus: Streaming data Parsing Data aggregation Challenge 10: Authentication Token Management System Focus: Security principles Token expiration Backend architecture --- Senior Engineer Evaluation Framework A strong candidate should demonstrate: Technical Ability Correct algorithm selection Efficient implementation Clean Python practices Engineering Thinking Scalability awareness Error handling Production considerations Communication Skills Clear explanation of decisions Trade-off analysis Structured problem solving Senior-Level Indicators Understands system limitations Considers reliability Designs for future growth This interview set can be used for senior software engineering preparation, technical screening, mock interviews, and developer assessment programs.