DEV Community: Shivangi Sikarwar

SQL vs NoSQL

Shivangi Sikarwar — Mon, 02 Jun 2025 09:20:36 +0000

In backend development, choosing the right database system is one of the crucial steps. The database system can be broadly divided into two categories- SQL(Structured Query Language) Databases and NoSQL(Not Only SQL) Databases.
Both of them have different strengths and use cases to solve different problems. Understanding which to use when and why over the other can make or break the scalability, performance and flexibility of any application.

In this blog post you'll get to know about-

My understanding from SQL vs NoSQL
Real-world Examples:
- Flipkart's category system
- Netflix(Hybrid Model)
- Uber(Ride Sharing)
Why we use SQL and why we use NoSQL
CAP Theorem
Conclusion

🧠 Understanding SQL vs NoSQL

📘 What is SQL?

SQL Database also known as Relational Database Management System (RDBMS). They are based on a structured, table-based format and are widely used in applications where data integrity and consistency are crucial.

Key Features:

Structured Data: Data is organized in distinct rows and columns.
Fixed Schemas: Structure of your data must be defined before inserting any records.
ACID compliance: Ensures reliability and consistency in transactions.

Examples: MySQL, PostgreSQL, Oracle, etc.

📗 What is NoSQL?

NoSQL databases are non-relational, designed to store and retrieve large volumes of unstructured or semi-structured data. They offer a flexible schema and are optimized for horizontal scalability.

Key Features:

Flexible Schema: Fields can differ across records.
Data Formats: Can be document-based, key-value, wide-column, or graph-based.
High Scalability: Ideal for distributed data systems.
Eventual Consistency: Focus on performance and availability over strict consistency.

Examples: MongoDB, Firebase, Cassandra, CouchDB, DynamoDB

Real-World Examples

Flipkart: Categories and Product Filters

Flipkart, like other e-commerce platforms, uses a SQL database to manage structured data like product inventory, user accounts, orders, and payments. But for fast-loading filters (e.g., price range, colors, categories), they may store flexible product data using NoSQL (like MongoDB) to support quick read operations.

Netflix: Hybrid Model

Netflix uses a hybrid approach — SQL for core relational data like billing and user subscriptions, and NoSQL (Cassandra, Dynomite) for high-volume, low-latency data like viewing history, video recommendations, and real-time analytics.

Uber: Ride Sharing

Uber handles massive amounts of geospatial and user data in real time. They use MySQL for transactional and structured data like trips, users, and billing, and NoSQL for location tracking, ETA predictions, and surge pricing.

Why SQL and Why NoSQL?

Use Cases-

Data is structured: SQL if You have fixed schemas and relationships. NoSQL if you want to evolve schemas quickly.
You need complex queries: SQL if you require joins, constraints, and relational logic. NoSQL if you mostly use key-value or document lookups.
Strict consistency required: SQL if data integrity and transaction reliability is critical. NoSQL if slight inconsistency is tolerable for better performance.
Scaling needs: SQL if vertical scaling is manageable. NoSQL if you need to scale horizontally across servers.
Development speed and flexibility: SQL if schema changes are rare. NoSQL if you expect frequent schema changes.

CAP Theorem

CAP theorem stands for Consistency, Availability, and Partition Tolerance. It states that a distributed system can only guarantee two out of the three at a time:

Consistency: Every request gets the latest data.
Availability: Every request gets a response, even if it’s not the latest.
Partition Tolerance: The system continues to work despite network failures.

Example:
Banking: CP Theorem
Uber: AP Theorem

Conclusion

The choice between SQL and NoSQL isn't about which is better — it's about which fits your application's needs.

If you’re building a banking app or inventory system, go with SQL for its strong data integrity and relational structure.
If you’re working on a real-time chat app, or large-scale analytics system, NoSQL might be the better fit.

Many big companies use a hybrid architecture that takes advantage of the strengths of each. Mastering both will make you a more versatile backend developer.

How I’m Using Atomic Habits to Land My First Web Developer Job

Shivangi Sikarwar — Sat, 08 Feb 2025 05:36:25 +0000

Introduction

**
Becoming a self-taught web developer is challenging, but I’ve found that applying the principles from Atomic Habits by James Clear has helped me stay consistent and make progress every day. Instead of focusing on just the end goal of landing a job, I’m building habits that make me a better developer daily. In this blog, I’ll share how I’m using Atomic Habits to improve my skills, apply for jobs, and grow my network—one small step at a time.

1. Identity-Based Habits: Becoming a Developer

In Atomic Habits, James Clear talks about identity-based habits, where you shift your mindset from “I want to be a developer” to “I am a developer.”

How I apply this:

I write code every day, even if it’s just a small feature or a bug fix.
I contribute to GitHub and engage in open-source projects.
I tell myself, “What would a web developer do today?”—and then I do it!

By consistently reinforcing this identity, I’ve started to feel more confident in my skills and more motivated to keep learning.

2. Small Daily Wins: The 1% Rule

Clear emphasizes that small improvements compound over time. Instead of aiming for big jumps, I focus on improving just 1% every day.

How I apply this:

Solve one coding problem per day.
Read one blog post or watch a tutorial about JavaScript, React, or backend technologies.
Improve one feature in my project daily.
Apply for at least one job or network with one recruiter per day.

These small efforts add up over weeks and months, making me more skilled and job-ready.

3. Habit Stacking: Making Learning Automatic

To make habits stick, I use habit stacking—attaching new habits to existing ones. Examples:

After my morning tea, I code for 30 minutes.
After brushing my teeth at night, I read a blog post or documentation.
When I open my laptop, I first check GitHub before social media.

This ensures I stick to my learning routine effortlessly.

4. The Two-Minute Rule: Just Start

Sometimes, getting started is the hardest part. Clear suggests the Two-Minute Rule: make habits so easy that you can’t say no.

How I apply this:

Instead of “I will build a full-stack project,” I say “I will write one line of code.”
Instead of “I will study JavaScript for an hour,” I say “I will read one paragraph about closures.”

Once I start, I usually end up doing more than I planned!

5. Tracking Progress: Keeping Myself Accountable

Tracking habits makes them more satisfying. I use a Google Sheet Habit Tracker to log:
✅ Daily coding sessions
✅ Job applications
✅ Networking activities
✅ GitHub contributions

By checking off tasks, I feel accomplished and stay motivated!

6. Building a System, Not Just Goals

Instead of just setting the goal “Get a developer job,” I focus on a system:
✅ Daily coding practice → Builds skills
✅ Personal projects → Showcases experience
✅ Networking & open-source contributions → Creates opportunities
✅ Consistently applying to jobs → Increases interview chances

By following this system, getting a job becomes a natural outcome rather than an impossible target.

7. Never Miss Twice: Staying Consistent

Life happens, and I might miss a day of coding or learning. But I follow the Never Miss Twice rule: if I skip a day, I make sure to get back on track the next day.

Conclusion: Small Steps, Big Results

By applying the principles from Atomic Habits, I’ve built a system that helps me stay consistent, improve daily, and get closer to landing my first web developer job. If you’re on the same journey, start small, track your progress, and show up every day—your future self will thank you!

Are you a self-taught developer too? Let’s connect and support each other! 🚀