DEV Community: mdSamee

Storage Buckets Demystified: How the Cloud Stores Your World

mdSamee — Thu, 08 May 2025 11:54:23 +0000

In today’s digital world, we rely heavily on cloud storage for everything from uploading photos and documents to streaming music and videos. Behind the scenes, this magic happens through cloud storage buckets — the containers that hold and serve your files. Whether you're building a web app, mobile app understanding cloud storage is crucial.

1. What Are Cloud Storage Buckets?

Imagine you're organizing your personal files on your computer. You might create folders for photos, documents, music, etc. In the cloud, this idea is scaled up to storage buckets — containers that hold files in the cloud.

Key Characteristics of Cloud Storage Buckets:

Objects: Everything inside a bucket is considered an "object," which can be a file (e.g., images, PDFs) or metadata about the file.
Public or Private Access: Buckets can be publicly accessible (anyone with a link can view) or private (restricted by roles or tokens).
Scalability: Buckets are designed to scale effortlessly, from a few files to petabytes of data.

2. How Storage Buckets Power Real-World Applications

Let's connect cloud storage with real-world scenarios. Here’s how various industries leverage storage buckets:

Social Media Platforms (e.g., Instagram, Twitter): These platforms store user-uploaded photos and videos in storage buckets. The content is typically public and needs to be fast and accessible.
Document Management Systems (e.g., Google Docs): Files such as text documents, PDFs, and presentations are uploaded to storage buckets (Google Cloud Storage for GCP, Firebase for smaller apps).

Cloud storage systems like Amazon S3, Firebase Storage, and Supabase Storage provide easy access to these buckets. Let's dive into how these systems compare and which one might be best suited for your needs.

3. Supabase, Firebase, AWS S3 — What’s the Difference?

Cloud storage systems all serve the same basic function — storing and retrieving files — but they have different features, integrations, and pricing.

Feature	Supabase Storage	Firebase Storage	AWS S3
Ease of Setup	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐
Pricing	Generous free tier	Free for up to 1GB	Pay-as-you-go (more scalable)
Access Control	Fine-grained via row-level policies	Integrated with Firebase Auth	IAM policies and access keys
Integration	Best for full-stack developers	Ideal for mobile apps	Flexible, enterprise-grade
Best For	Startups, DB + Storage apps	Mobile apps	Large-scale applications

Supabase Storage:

Supabase’s storage solution is a great fit for developers already working with PostgreSQL, as it integrates seamlessly with the database. It allows you to manage files securely and efficiently while keeping your storage access and user data tightly integrated.

4. Setting Up and Implementing Supabase Storage Bucket

Now, let's break down how you can implement Supabase Storage Buckets in your projects.

Step 1: Setup Project in Supabase

Create a Supabase Account: Go to Supabase and create an account.
Create a New Project: From the Supabase dashboard, click "New Project", choose your database and region.
Enable Storage: Once your project is created, navigate to the "Storage" tab and create a Bucket.

Step 2: Configure Bucket Access and Permissions

Supabase gives you the flexibility to define access control for each file in your bucket.

Set Bucket Public or Private:

Public Access: Anyone can access files via a URL (great for media files).
Private Access: Files require authentication via JWT tokens (recommended for sensitive data like user documents).

Example policy for allowing file uploads only if the user is authenticated:

-- Example Policy for file upload
CREATE POLICY "Allow authenticated users to upload files"
    ON storage.objects
    FOR INSERT
    USING (auth.uid() IS NOT NULL);

Step 3: Upload and Retrieve Files

Now let’s dive into the code to upload and retrieve files.

Upload File to Supabase Storage

First, install the Supabase client:

npm install @supabase/supabase-js

Now, you can upload a file using the following JavaScript code (in a React or Node.js environment):

import { createClient } from '@supabase/supabase-js'

const supabase = createClient('https://your-project.supabase.co', 'your-public-anon-key')

// Upload file
async function uploadFile(file) {
  const { data, error } = await supabase.storage
    .from('your-bucket-name')
    .upload('file-path-in-bucket/' + file.name, file)

  if (error) {
    console.error('Error uploading file:', error.message)
  } else {
    console.log('File uploaded:', data)
  }
}

Download File from Supabase Storage

You can retrieve a file from your bucket using the download method:

// Download file
async function downloadFile(filePath) {
  const { data, error } = await supabase.storage
    .from('your-bucket-name')
    .download(filePath)

  if (error) {
    console.error('Error downloading file:', error.message)
  } else {
    const url = URL.createObjectURL(data)
    // Do something with the URL (e.g., display or save)
    console.log('Download URL:', url)
  }
}

5. Security and Permissions: Protecting Your Files

Files in your storage buckets can be accessed in two ways: publicly or privately. Private access is crucial for ensuring that sensitive data, such as user documents, is protected.

In Supabase, you can set policies to control file access:

Public Access: By default, anyone with a link can access files.
Private Access: Use JWT tokens or row-level security policies to restrict access to authenticated users only.

Example of a policy for downloading files only for authenticated users:

CREATE POLICY "Allow authenticated users to download files"
    ON storage.objects
    FOR SELECT
    USING (auth.uid() IS NOT NULL);

In a full-stack application, ensure that only authorized users can upload or download files by implementing strong authentication and authorization mechanisms, such as OAuth or JWT-based login.

7. Conclusion: Why Cloud Storage Buckets Are Essential for Your App

Cloud storage buckets have become a critical part of modern web and mobile applications. They are scalable, secure, and easy to implement. Whether you’re building a small app or an enterprise-level system, understanding and integrating a cloud storage bucket is essential.

For developers working with Supabase, integrating storage buckets with your PostgreSQL database is seamless, and the pricing is attractive for startups and small businesses. With options like public or private access and granular control over permissions, Supabase Storage is a great choice for developers looking for simplicity and power in file management.

Next Steps:

If you’re starting a project that needs file management, try integrating Supabase Storage into your app. It's perfect for managing documents, media, backups, and more — all while keeping your app scalable.

Bonus: Don't forget to test file permissions thoroughly, especially for sensitive data!

Frameworks Change, Foundations Don’t: The Power of Core Skills

mdSamee — Thu, 17 Apr 2025 05:17:47 +0000

When I started my journey as a developer, I was fascinated by the shiny things—frameworks, libraries, no-code tools, and fast ways to build cool apps. I jumped into React, Django, Flutter... and for a while, it felt great. But eventually, I hit a wall. And that’s when I realized the real power lies in core skills.

What Are Core Skills?

In simple words, core skills are the fundamentals. The things that never change no matter what stack you're working on:

Data Structures & Algorithms
Object-Oriented Programming (OOP)
Databases and how SQL really works
How the web works (HTTP, APIs, sessions)
Git, Linux, and version control
Understanding memory, time complexity, and architecture

These are not trendy, but they’re timeless.

The Day I Switched Stacks
I still remember the first time I had to switch my stack. I was comfortable building applications using Django and Node.js — both frameworks where I knew the ins and outs. But then came a new opportunity: I had to work on a project using Spring Boot.

Java? Spring? Annotations everywhere? At first glance, it was overwhelming.

But here's what surprised me — I didn’t feel like a complete beginner. Sure, the syntax was different, and the tooling had a learning curve. But I realized that the core concepts were the same. Whether it was building REST APIs, managing database models, or handling request-response cycles — the logic I’d learned through Django and Node.js applied here too.

I already knew:

How an MVC architecture works

The basics of HTTP and routing

Database operations using ORM principles

Dependency injection, even if it had a different name or implementation

Because I had worked hard on my core skills, the transition wasn’t as difficult as I feared. I wasn't just copying and pasting code from tutorials — I was understanding what the code was doing, no matter the language or framework.

The Struggle Without Core

Early on, I built projects using just tutorials and templates. But when something broke, I had no idea why.

When I was asked to optimize a function, I didn’t know how to analyze its time complexity.

And when I sat for interviews, I struggled with basic DSA questions, even though I could build full apps.

That’s when it hit me: frameworks teach you to build, but core skills teach you to think.

How Core Helped Me Grow

I could debug faster because I understood how memory, variables, and loops actually worked under the hood.
I could read and contribute to open-source projects that didn’t use my familiar stack.
I got better at designing scalable systems—because I wasn’t just coding, I was solving problems.

What I Did to Strengthen My Core

I stopped blindly following tutorials and started learning why things work the way they do. I:

Spent time on DSA using LeetCode & GeeksforGeeks
Read books like “Cracking the Coding Interview” and “You Don’t Know JS”
Built small projects from scratch using just core languages (no frameworks)
Studied how databases, operating systems, and networks actually function

It wasn’t easy—but it was worth it.

Final Thoughts

Today, when people ask me, “How do I switch from frontend to backend?” or “How do I learn a new tech stack?”—my answer is always the same:
Focus on the core.

Because once you understand the foundation, the tools and frameworks become just that—tools, not barriers.

One Line I Always Remember:

"Frameworks make you a developer, but core skills make you unstoppable."

Hello World Isn’t Enough: The Reality of Coding After College

mdSamee — Wed, 16 Apr 2025 05:15:28 +0000

What Are Universities Teaching Today?

In most Indian universities, the programming curriculum hasn’t evolved much in the past decade. The focus is still on languages like C and C++ for foundational logic, and Java is taught in a very textbook-oriented way, often with outdated versions. Some institutions have started introducing Python, but it’s usually limited to syntax and basic scripting. The syllabus includes subjects like Data Structures, Operating Systems, DBMS, and Computer Networks, but they’re taught with an exam-oriented approach. Real-world technologies like version control, cloud computing, REST APIs, or frameworks like React, Node.js, or Django are almost entirely missing from the curriculum.

Are Teachers Updated? Mostly No.

A major challenge is that many faculty members were trained years ago and haven’t updated their knowledge with current industry trends. Most of them haven’t worked in real-world development environments and continue teaching from textbooks. As a result, they are unaware of tools and practices used by actual software teams today, like Git, CI/CD pipelines, DevOps, or collaborative platforms like GitHub. Students are rarely exposed to agile development, design patterns, or debugging real codebases. The lack of continuous learning among educators contributes directly to the skill gap that fresh graduates face in the tech industry.

Infrastructure Still in the Past

University computer labs often run on outdated systems and software. You’ll still find Turbo C++, BlueJ, or even Notepad being used as default environments for writing code. IDEs like VS Code or IntelliJ are rarely encouraged. In many cases, students are not taught how to push their code to GitHub or deploy their projects online. Access to cloud services, servers, or real deployment scenarios is almost nonexistent. Infrastructure that should empower creativity ends up limiting exposure to how development is actually done in the professional world.

Marks Matter More Than Skills

The current academic system continues to prioritize marks over skills. Students are trained to memorize code and reproduce it in exams rather than solve real-world problems or build working applications. Practical exams often focus on writing algorithms on paper, instead of implementing them in a meaningful project. Viva questions rarely assess problem-solving or development thinking. As a result, many students focus on rote learning just to clear exams — missing out on opportunities to build portfolios, work on real projects, or develop skills that companies actually look for.

In addition to practical coding skills, a solid theoretical foundation is crucial for long-term success in programming. Understanding algorithms, data structures, design patterns, and software architecture principles are vital for building efficient, maintainable, and scalable systems. These concepts are often emphasized in college curriculums, but once out in the field, they are frequently overshadowed by the urgency of solving immediate technical problems. However, it’s the theoretical knowledge that empowers developers to make informed decisions, optimize performance, and create solutions that stand the test of time. In the end, coding is not just about writing functional code, but understanding the deeper principles that guide the creation of robust software.

Beyond Hello World?

In real-life coding, you'll encounter various tools not typically taught in university, including:

Version Control: Git and platforms like GitHub, GitLab, or Bitbucket are essential for managing code, collaborating with teams, and tracking changes.
Project Management: Tools like Jira, Trello, or Asana help manage tasks, sprints, and project timelines in an agile workflow.
Containerization: Docker is widely used for creating, deploying, and managing applications in isolated environments, ensuring consistency across platforms.
CI/CD: Jenkins, CircleCI, and Travis CI are tools for automating the testing, building, and deployment of applications.
Cloud Platforms: AWS, Azure, and Google Cloud offer scalable infrastructure for deploying and managing applications at scale.
IDEs & Editors: Visual Studio Code, IntelliJ IDEA, and PyCharm are commonly used for development, offering features like code completion and debugging tools.
Monitoring and Logging: Tools like Prometheus, Grafana, and Splunk help monitor applications and systems, providing insights into performance and errors in production.
Testing Frameworks: JUnit, Mocha, Selenium, and Postman are used for automated unit tests, integration tests, and API testing.
Security Tools: Tools like OWASP ZAP and Burp Suite help identify vulnerabilities and ensure application security.

These tools help streamline development, improve code quality, and ensure scalability, security, and performance in real-world environments.

In addition to tools, there are several trends in the tech industry that are rarely covered in university curricula:

Cloud Computing: AWS, Google Cloud, and Azure for scalable, cloud-based apps.
DevOps: Tools like Docker, Jenkins, and Kubernetes for continuous integration and deployment.
Microservices: Building scalable apps with small, independent services.
AI/ML: Real-world applications of machine learning with TensorFlow and PyTorch.
Blockchain: Developing decentralized apps and smart contracts on platforms like Ethereum.
Edge Computing: Reducing latency by processing data closer to its source.
Serverless: Using AWS Lambda or Google Functions to build apps without managing servers.
Quantum Computing: Early-stage tech offering breakthroughs in complex problem-solving.
AR/VR: Immersive experiences built with Unity and Unreal Engine.
No-Code/Low-Code: Tools like Bubble and Webflow for rapid app development without coding.

These trends represent the cutting edge of the tech industry, and mastering them can help you stay competitive in the rapidly evolving world of software development.

Discovering the Gap Between University Learning and Real-World Development

I underwent corporate training that I realized how disconnected the academic syllabus was from real-world development practices. In my corporate training, I was introduced to tools like Git, cloud computing, and agile workflows—concepts that I had never encountered during my university education. This experience made me realize the stark difference between what I had learned in college and what was expected of me in the professional world. It was eye-opening and set me on the path to bridging that gap.

Conclusion

In conclusion, real-life coding demands a hands-on, practical approach that goes beyond what is taught in university. While concepts like algorithms and data structures are fundamental, modern tools and trends like cloud computing, DevOps, and AI/ML are what shape the future of development. It's important to note that coding isn't something you can master by just watching outdated PowerPoint presentations or learning older versions of languages like Java or Python. The key to becoming a proficient developer is continuous learning, staying updated with the latest trends, and gaining real-world experience through hands-on projects.