Get live statistics and analysis of Raul Junco's profile on X / Twitter

Sr. Software Engineer working at a startup

Backend survival kit. 👇

Backend projects will take you to a Senior position. Design and Improve a Relational Database - Design a Database - Apply Normalization - Improve Indexing - Do Query optimization Build a RESTful API with Authentication & Authorization - HTTP Methods (GET, POST, PUT, and DELETE) - System modeling and design - Data Protection - User management - Tests with Postman Implement a Caching Layer Caching helps reduce the load on databases and improves response times. The cache will show how you optimize performance and handle high-traffic loads. Microservices Architecture If you land in a large company, you have to deal with Microservices. - Design a Distributed System - Handle communication between services - Learn about Fault Tolerance DevOps and Infrastructure Understanding how to deploy applications: - CI/CD - Docker - Kubernetes - IaC tools like Terraform or CloudFormation, ARM Also, technical expertise is only part of the equation. A Senior role demands: - Leadership - Mentorship - Effective communication The theory will help, but what will make the difference is the hands-on experience.

An Interview question every developer should know. What's the difference between Tokens and API keys? We use API keys and tokens for authentication and authorization. But they serve different purposes and have distinct characteristics. Tokens (like JWT - JSON Web Tokens): Carries user context and permissions for authentication and authorization. Encoded with a user ID, permissions, and expiration time, often in JWT format. Critical for user-specific access, like accessing a user's profile data in an e-commerce platform. It is issued by an authentication server after user login and contains user-specific information. API Key: Primarily for identifying the application or the consumer making the API call. They are long strings we pass in the header or as a query parameter in the API request. You use API keys when access does not involve user context. For example, accessing a public API or service-to-service communication. They are long-lived and created through the API provider's platform or admin console. In simple terms: - Tokens are for managing user sessions, permissions, and context. - API keys are for identifying applications. Which one have you used the most?

80% of System Design Interviews are based on 20% of the problems. Here is what you need to master. 1. Scalable Data Storage • Relational vs. NoSQL: Know when to use SQL vs. NoSQL databases. • Partitioning: Vertical and horizontal partitioning (sharding). Understand trade-offs. • Indexing: Covering indexes, primary vs. secondary indexes. • Consistency Models: Strong, eventual, causal. 2. Caching • Client-side vs. Server-side Cache: Understand where caching should happen. • Caching Strategies: Write-through, write-back, write-around. • Distributed Cache: Redis, Memcached. • Cache Eviction Policies: LRU, LFU, etc. 3. Load Balancing • Horizontal Scaling: Why and how to horizontally scale services. • Load Balancing Techniques: Round-robin, consistent hashing. • Reverse Proxy: Understand how to use Nginx, HAProxy. 4. Asynchronous Processing • Message Brokers: Kafka, RabbitMQ. When to use queues vs. streams. • Event-Driven Architecture: Benefits of decoupling and event sourcing. • Task Queues: For delayed jobs or retries. 5. Database Read and Write Scaling • Read Scaling: Master replication, read replicas. • Write Scaling: Challenges with partitioning for writes, leader-election. • CAP Theorem: Consistency, Availability, or Partition tolerance may be compromised. 6. Distributed Systems Concepts • Consensus Algorithms: Paxos, Raft. • Conflict Resolution: Last Write Wins, CRDTs, vector clocks for data reconciliation. 7. Reliability and Failover • Redundancy: Active-passive vs. active-active configurations. • Health Checks. • Retries and Circuit Breakers: How to protect systems from cascading failures. 8. CDNs (Content Delivery Networks) • Static Content Delivery: Why use a CDN, how does it work? • Caching at the Edge: How CDNs improve latency for end users. 9. API Design and Rate Management • REST vs. GraphQL: Difference and practical use-cases for each. • Pagination and Filtering: Strategies for efficiently fetching data. • API Versioning: Best practices for evolving APIs. • Throttle Requests: Why rate limiting is essential, algorithms like token bucket, leaky bucket. 10. Search Systems • Indexing: Building and maintaining indexes for fast search. • Full-Text Search Engines: ElasticSearch, Azure AI Search. • Ranking and Relevance: Basic understanding of how scoring works. 11. Monitoring, Observability and Security • Metrics Collection: Prometheus, Grafana. • Distributed Tracing: OpenTelemetry, Sentry. • Centralized Logging. • Authentication and Authorization: OAuth, JWT. • Encryption: Data in transit vs. data at rest. If you master these 13 areas, you'll be ready for most system design interviews thrown at you. Add more if you can 👇

A backend engineer asked me why I recommend Fundamentals of Data Engineering for backend folks. Because most backend engineers accidentally become data engineers the moment their API hits production. Backend = owns writes. Data Engineering = owns reads. But both eat the same consequences when the data sucks. If you learn Data Engineering fundamentals, you level up faster because you stop treating data as “someone else’s problem.” You get better at: - Designing schemas that won’t break downstream - Shipping clean, traceable events (no dual-write disasters) - Thinking in batch vs. streaming trade-offs - Debugging data issues faster than “blame analytics” - Building APIs that scale with actual usage patterns Backend without data fundamentals = “the feature works” Backend with data fundamentals = “the business trusts what you build” The short answer: Most backend engineers only understand half the system. This book helps you finally see the whole thing.

Most engineers stay average because they practice code questions. Top engineers get ahead because they practice system design questions. These 20 aren’t trivia. They’re the ones that reveal if you can actually scale, simplify, and ship. Read them. Save them. Drill them. Because the engineer who can design systems… …owns the room. Add more to this list.

System Design isn’t one big concept. It’s a staircase. Most engineers try to skip to “distributed systems.” Then, wonder why everything collapses under load. You can’t copy-paste scale. You earn it, step by step. Step 1: Foundations - Learn how data moves. - Networking. Databases. Caching. APIs. - You can’t scale what you don’t understand. Step 2: Mechanics - Learn how systems behave under stress. - Queues. Consistency. Observability. Failures. - This is where good engineers become reliable ones. Step 3: Architecture - Learn how to design for change. - Trade-offs. Evolution. Resilience. - You stop asking “how do I build this?” and start asking “how will this break?” Most people collect patterns. Few develop principles. The difference? Depth. The deeper you go, the less you rely on luck, and the more you rely on design.

Most engineers learn system design backwards. They jump to Kubernetes before they understand what a network packet even does. Here’s the order that actually makes you dangerous: 1. Networks first HTTP. TCP. DNS. Latency vs throughput. This is the part nobody studies. This is like trying to bench 300lbs without learning to squat. 2. Databases second SQL vs NoSQL, indexes, replication, and partitioning. If you can’t reason about data -> you can’t reason about scale. 3. Caching Redis, CDNs, TTLs, eviction policies. 70% of scaling wins come from avoiding queries. 4. Queues & Streams Kafka, RabbitMQ, SQS. This is how you decouple timelines and handle spikes without blowing up servers. 5. Load Balancing Round robin vs least connections vs consistent hashing. You understand how to scale horizontally without chaos. 6. Build 5 classic designs yourself - URL shortener - Rate limiter - Chat app - Feed system - Notifications 7. Read real-world post-mortems Real learning is failure exposure. You see what broke. You see WHY. You don’t become good at system design by memorizing diagrams. You become good by understanding the physics of distributed systems. Latency. Durability. Throughput. Availability. Cost. Those 5 forces rule everything.

In one system design interview, I used Kafka. In one system design interview, I used Redis. In one system design interview, I used S3. In ALL system design interviews, I used databases. Databases are the backbone of every design, no matter the scale, stack, or domain. If you understand how data is stored, queried, indexed, replicated, and partitioned, you already understand 70% of system design. Don’t get distracted by every new shiny component; queues, caches, and orchestrators come and go. But databases are forever. Relational, NoSQL, time-series, vector, the patterns evolve, but the principles stay the same: - Read and write paths - Indexing and caching - Transactions and isolation - Replication and partitioning Master how data flows, and you’ll see how every other part of the system connects. Learn databases deeply. Everything else is just optimization.

75% of developers will fail this SQL question. What's wrong with this script? The first time I faced this question, I jumped into the SQL syntax like crazy. But the syntax was OK; the problem was in the data and related to a concept called Cardinality. Cardinality refers to the number of unique values in a column relative to a table's total number of rows. • High Cardinality means the column has many unique values. • Low Cardinality means the column has few unique values. Creating an index on a column with low Cardinality is most of the time ineffective because: 1. Low Cardinality means each indexed value points to many rows, reducing the index's ability to narrow down the search. 2. Maintaining an index has a cost of storage and update time. For low cardinality columns, this overhead might outweigh the benefits. 3. Database query optimizers are smart; they know column statistics, including Cardinality. When they detect a low cardinality index, they often ignore it and perform a full table scan instead. A simple Example Consider a table "Employees" with 1 million records. Let's examine indexing on different columns: • ID: High Cardinality (1 million unique values). An index here would be very effective. • Name: High Cardinality (many unique names). An index could be helpful in searches. • Department: Medium Cardinality (10-20 unique values). An index might sometimes be useful but less effective than an ID or Name. • Gender: Very low cardinality (2-3 unique values). The query optimizer would likely ignore an index here. When to consider a Low Cardinality column? There are scenarios where indexing a low cardinality column might be beneficial. For example, combining low and high cardinality columns can be effective. 'CREATE INDEX idx_dept_emp ON Employees(Department, ID);' Now you know the basics about Cardinality! Save this post; it might help in your next interview.

Gold is never old; the same happens with good books. They are classics that have shaped my way of building. Add a good book below 👇

Hotel reservation is not a joke. Let’s build an example. Your system needs to support: • Search for rooms • View room details • Booking a room • View confirmation details Do all four features need the same response time? The answer is NO. The search should be faster,

Good SQL brings more Orders. A common mistake that turns LEFT JOIN into an INNER JOIN. In a LEFT JOIN, all records from the left table and the matching records from the right table are included. So far, so good, but there is a catch. If you add a condition in the WHERE clause…

Backend projects will take you to a Senior position. Design and Improve a Relational Database - Design a Database - Apply Normalization - Improve Indexing - Do Query optimization Build a REST-style API with Authentication & Authorization - HTTP Methods (GET, POST, PUT, and DELETE) - System modeling and design - Data Protection - User management - Tests with Postman Implement a Caching Layer Caching helps reduce the load on databases and improves response times. The cache will show how you optimize performance and handle high-traffic loads. Microservices Architecture If you land in a large company, you must deal with Microservices. - Design a Distributed System - Handle communication between services - Learn about Fault Tolerance DevOps and Infrastructure Understanding how to deploy applications: - CI/CD - Docker - Kubernetes - IaC tools like Terraform or CloudFormation, ARM Also, technical expertise is only part of the equation. A Senior role demands: - Leadership - Mentorship - Effective communication The theory will help, but what will make the difference is the hands-on experience.

Sr. Software Engineer working at a startup

Backend survival kit. 👇

I have been in backend development for more than 15 years. It is a challenging field and It took me some time to find my path to becoming a good one. But if I started over, these are the 6 steps I would follow. 1 of 6

System Design isn’t one big concept. It’s a staircase. Most engineers try to skip to “distributed systems.” Then, wonder why everything collapses under load. You can’t copy-paste scale. You earn it, step by step. Step 1: Foundations - Learn how data moves. - Networking. Databases. Caching. APIs. - You can’t scale what you don’t understand. Step 2: Mechanics - Learn how systems behave under stress. - Queues. Consistency. Observability. Failures. - This is where good engineers become reliable ones. Step 3: Architecture - Learn how to design for change. - Trade-offs. Evolution. Resilience. - You stop asking “how do I build this?” and start asking “how will this break?” Most people collect patterns. Few develop principles. The difference? Depth. The deeper you go, the less you rely on luck, and the more you rely on design.

75% of developers will fail this SQL question. What's wrong with this script? The first time I faced this question, I jumped into the SQL syntax like crazy. But the syntax was OK; the problem was in the data and related to a concept called Cardinality. Cardinality refers to the number of unique values in a column relative to a table's total number of rows. • High Cardinality means the column has many unique values. • Low Cardinality means the column has few unique values. Creating an index on a column with low Cardinality is most of the time ineffective because: 1. Low Cardinality means each indexed value points to many rows, reducing the index's ability to narrow down the search. 2. Maintaining an index has a cost of storage and update time. For low cardinality columns, this overhead might outweigh the benefits. 3. Database query optimizers are smart; they know column statistics, including Cardinality. When they detect a low cardinality index, they often ignore it and perform a full table scan instead. A simple Example Consider a table "Employees" with 1 million records. Let's examine indexing on different columns: • ID: High Cardinality (1 million unique values). An index here would be very effective. • Name: High Cardinality (many unique names). An index could be helpful in searches. • Department: Medium Cardinality (10-20 unique values). An index might sometimes be useful but less effective than an ID or Name. • Gender: Very low cardinality (2-3 unique values). The query optimizer would likely ignore an index here. When to consider a Low Cardinality column? There are scenarios where indexing a low cardinality column might be beneficial. For example, combining low and high cardinality columns can be effective. 'CREATE INDEX idx_dept_emp ON Employees(Department, ID);' Now you know the basics about Cardinality! Save this post; it might help in your next interview.

Most engineers learn system design backwards. They jump to Kubernetes before they understand what a network packet even does. Here’s the order that actually makes you dangerous: 1. Networks first HTTP. TCP. DNS. Latency vs throughput. This is the part nobody studies. This is like trying to bench 300lbs without learning to squat. 2. Databases second SQL vs NoSQL, indexes, replication, and partitioning. If you can’t reason about data -> you can’t reason about scale. 3. Caching Redis, CDNs, TTLs, eviction policies. 70% of scaling wins come from avoiding queries. 4. Queues & Streams Kafka, RabbitMQ, SQS. This is how you decouple timelines and handle spikes without blowing up servers. 5. Load Balancing Round robin vs least connections vs consistent hashing. You understand how to scale horizontally without chaos. 6. Build 5 classic designs yourself - URL shortener - Rate limiter - Chat app - Feed system - Notifications 7. Read real-world post-mortems Real learning is failure exposure. You see what broke. You see WHY. You don’t become good at system design by memorizing diagrams. You become good by understanding the physics of distributed systems. Latency. Durability. Throughput. Availability. Cost. Those 5 forces rule everything.

A backend engineer asked me why I recommend Fundamentals of Data Engineering for backend folks. Because most backend engineers accidentally become data engineers the moment their API hits production. Backend = owns writes. Data Engineering = owns reads. But both eat the same consequences when the data sucks. If you learn Data Engineering fundamentals, you level up faster because you stop treating data as “someone else’s problem.” You get better at: - Designing schemas that won’t break downstream - Shipping clean, traceable events (no dual-write disasters) - Thinking in batch vs. streaming trade-offs - Debugging data issues faster than “blame analytics” - Building APIs that scale with actual usage patterns Backend without data fundamentals = “the feature works” Backend with data fundamentals = “the business trusts what you build” The short answer: Most backend engineers only understand half the system. This book helps you finally see the whole thing.

Most engineers stay average because they practice code questions. Top engineers get ahead because they practice system design questions. These 20 aren’t trivia. They’re the ones that reveal if you can actually scale, simplify, and ship. Read them. Save them. Drill them. Because the engineer who can design systems… …owns the room. Add more to this list.

An Interview question every developer should know. What's the difference between Tokens and API keys? We use API keys and tokens for authentication and authorization. But they serve different purposes and have distinct characteristics. Tokens (like JWT - JSON Web Tokens): Carries user context and permissions for authentication and authorization. Encoded with a user ID, permissions, and expiration time, often in JWT format. Critical for user-specific access, like accessing a user's profile data in an e-commerce platform. It is issued by an authentication server after user login and contains user-specific information. API Key: Primarily for identifying the application or the consumer making the API call. They are long strings we pass in the header or as a query parameter in the API request. You use API keys when access does not involve user context. For example, accessing a public API or service-to-service communication. They are long-lived and created through the API provider's platform or admin console. In simple terms: - Tokens are for managing user sessions, permissions, and context. - API keys are for identifying applications. Which one have you used the most?

In one system design interview, I used Kafka. In one system design interview, I used Redis. In one system design interview, I used S3. In ALL system design interviews, I used databases. Databases are the backbone of every design, no matter the scale, stack, or domain. If you understand how data is stored, queried, indexed, replicated, and partitioned, you already understand 70% of system design. Don’t get distracted by every new shiny component; queues, caches, and orchestrators come and go. But databases are forever. Relational, NoSQL, time-series, vector, the patterns evolve, but the principles stay the same: - Read and write paths - Indexing and caching - Transactions and isolation - Replication and partitioning Master how data flows, and you’ll see how every other part of the system connects. Learn databases deeply. Everything else is just optimization.

I used to overthink which database to choose. I’d get lost in benchmarks, blog posts, and vendor promises…Until I found this simple flowchart. It cuts through the noise and helps you decide based on just two things: - What kind of data do you have? - What are you doing with it? Here’s the gist: Structured + OLTP? → Relational DB Structured + OLAP? → Columnar DB Unstructured? → Object Store Semistructured? Dictionary-style? Use Key-Value or In-memory Lots of relationships? Go Graph Time-based? → Time-series Location data? → Geo DB Nested JSON? → Document Store Search heavy? → Search DB This diagram saved me hours of overthinking. Maybe it will help you too. What’s your default database choice, and when do you switch?

Backend projects will take you to a Senior position. Design and Improve a Relational Database - Design a Database - Apply Normalization - Improve Indexing - Do Query optimization Build a RESTful API with Authentication & Authorization - HTTP Methods (GET, POST, PUT, and DELETE) - System modeling and design - Data Protection - User management - Tests with Postman Implement a Caching Layer Caching helps reduce the load on databases and improves response times. The cache will show how you optimize performance and handle high-traffic loads. Microservices Architecture If you land in a large company, you have to deal with Microservices. - Design a Distributed System - Handle communication between services - Learn about Fault Tolerance DevOps and Infrastructure Understanding how to deploy applications: - CI/CD - Docker - Kubernetes - IaC tools like Terraform or CloudFormation, ARM Also, technical expertise is only part of the equation. A Senior role demands: - Leadership - Mentorship - Effective communication The theory will help, but what will make the difference is the hands-on experience.

Ten years ago, you only needed to know GoF patterns, and you could call yourself a good developer. That's not true anymore. If you want to build Hight Quality software, you need architectural knowledge. 4 basic architecture to start.

Writing tests is not free. - You have to set up mocks. - You have to maintain your tests. - Sometimes, you have to seed your data. But I would rather spend 1 hour writing tests than 5 hours fixing bugs in production.

My first app was a calculator, which didn't help me get a job. If I had to start over, I would create an API. Coding exercises can help you practice algorithms and syntax, but they are far from a real software development job. 7 steps to build your first API: 1. Select a Use