Technical Interview Questions for Brazil (2026): Examples + Tips

Sample Answer

Before I design anything, let me clarify scope. Are we talking about a read-heavy or write-heavy system? What scale — DAU, URLs per second? Any requirements around custom aliases or analytics? (Interviewer confirms: 100M URLs, 1B reads/day, analytics needed.) OK. The core is a hash function that maps a long URL to a 6-7 character string. I'd use base62 encoding on an auto-incrementing ID to guarantee uniqueness and predictable length. For the data layer: a relational DB (Postgres) handles writes; the reads I'd cache aggressively in Redis with a TTL matching average access patterns — most URL visits cluster in the first 24-48 hours of sharing. For scale, I'd put a CDN in front of the redirect service since the redirect response is deterministic and cacheable. The analytics pipeline is the interesting part — I'd fan out click events to Kafka and process them asynchronously so the redirect latency stays sub-10ms.

Sample Answer

Let me start with edge cases: empty list, single-node list — those should return the input unchanged. For the general case: I'll use three pointers — prev (null initially), curr (head), and next. At each step: save next, point curr.next to prev, advance prev to curr, advance curr to next. When curr is null, prev is the new head. This is O(n) time and O(1) space. Want me to code it up or walk through a trace on an example? (Codes the solution.) One thing I'd add in production: I'd check whether the caller wants a copy rather than in-place modification — this mutates the original list, which can be a source of bugs if callers hold references to the original nodes.

Sample Answer

SQL databases enforce a fixed schema and use ACID transactions — strong consistency, relational joins, well-suited for financial data, order systems, anything where integrity and relational queries matter. NoSQL is a family of systems (document, key-value, graph, wide-column) optimized for different access patterns: MongoDB for flexible document storage, Redis for key-value caching, Cassandra for high-write-throughput time-series data. The tradeoff is usually flexibility and scale versus consistency guarantees. I'd use Postgres for a user accounts and transactions system where I need joins and strong consistency. I'd use Cassandra for event tracking at billion-event scale where writes are append-only and I never need cross-partition queries. For most modern applications, the answer is both — a relational DB for transactional data and a cache or document store for read-optimized access.

Sample Answer

Step one: define "slow." Check the monitoring — is this a recent regression or a baseline issue? If recent, what changed? Deployments, traffic spike, upstream dependency? Step two: profile the request path. I'd add trace IDs if not present, then use APM tooling (Datadog, New Relic) to see where latency lives — is it the application layer, the database, or a downstream service? Step three: database queries are 80% of API slowness in my experience. I'd pull the query log, identify N+1 queries or missing indexes, and check explain plans. Step four: if it's application-level, I'd profile memory and CPU to look for contention. Step five: validate the fix in staging with a load test before deploying. Throughout, I'd communicate the diagnosis and ETA to stakeholders proactively rather than going dark.

Sample Answer

A race condition occurs when two threads or processes access and modify shared state concurrently in a way that produces incorrect results because the outcome depends on execution order. Classic example: two transactions read a bank balance as $100, both decide to withdraw $80, both check "is balance >= 80?" and both say yes, both subtract, and you end up with -$60. Prevention strategies: in databases, use SELECT FOR UPDATE to lock the row during the read-modify-write cycle, or use optimistic locking with a version column. In application code, use mutexes or semaphores to protect critical sections. At the system level, prefer message queues that serialize operations on shared resources. The right solution depends on the context — I'd always prefer database-level guarantees for financial operations over application-level locking.