DEV Community: Rajon Dey

The Complete Software Development Flow: From Idea to Production

Rajon Dey — Thu, 26 Feb 2026 13:29:14 +0000

Most developers start coding too early. Including me!

Here's a practical, end-to-end development flow you can follow when building any serious software product.

No theory. Just structure.

0. Idea Foundation

Problem Definition
Target Users
MVP Feature List
Tech Stack Decision
Architecture Style Decision

1. Planning & Design

Requirement Breakdown
User Flow Diagram
Wireframes
ER Diagram
System Design
API Contract Draft (Endpoints + Payloads)
Database Schema Draft
Folder Structure Planning

2. Backend Development

Project Initialization
Environment Configuration
Linting / Formatting Setup
Dependency Installation
Base Folder Structure Creation
Database Connection Setup
Models / Schemas Creation
Migrations Setup
Seed Data Setup
Authentication Setup
Middleware Layer
Business Logic (Services)
Controllers
API Routes
Validation Layer
Error Handling Layer
Logging
API Documentation
Backend Unit Tests

3. Frontend Development

Project Initialization
Dependency Installation
Folder Structure Setup
Routing Setup
Layout System
State Management
API Client Setup
Authentication Integration
Reusable Components
Pages Implementation
Forms & Validation
Loading & Error States
Responsive Design
Frontend Tests

4. Integration

Connect Frontend to APIs
Token Handling
Protected Routes
API Error Mapping
Edge Case Handling
Performance Optimization

5. Security & Optimization

Input Sanitization
Rate Limiting
CORS Configuration
Environment Security
Database Indexing
Query Optimization
Code Splitting
Bundle Optimization

6. Testing & QA

Manual Testing
Integration Testing
End-to-End Testing
Cross-Browser Testing
Mobile Responsiveness Testing
Bug Fixing

7. Deployment

Production Environment Setup
Production Database Setup
CI/CD Pipeline Setup
Build Optimization
Deploy Backend
Deploy Frontend
Domain Configuration
SSL Setup
CDN Setup

8. Post-Launch

Monitoring Setup
Error Tracking
Analytics Integration
Backup Strategy
Version Tagging
Documentation Update
Feedback Collection
Iteration Planning

If you're building real software, structure matters more than speed.

Build better. Ship smarter. https://developer-data.beehiiv.com/

Developers: 2025 Was About Speed. 2026 Is About Judgment.

Rajon Dey — Wed, 07 Jan 2026 12:57:56 +0000

A simple list of what really happened in 2025 - and what developers should realistically expect in 2026.

What Actually Happened in 2025

1. AI Became Part of Daily Development: 70% devs used Copilot/Cursor/ChatGPT for boilerplate/debugging. Speed increased. Quality depends on human judgment.

2. Writing code got faster, but thinking did not: AI reduced typing time, but system design, trade-offs, and architecture still relied on human input. Teams that rushed shipped faster, and broke faster.

3. Performance stopped being optional: Core Web Vitals affected SEO, revenue, and user trust. Edge computing and Jamstack setups reduced latency by up to 40%. Architecture > frontend tweaks.

4. Frameworks Stabilized: Stability won over novelty: React stayed dominant (~40%). Svelte grew steadily (+15%). Node.js remained the default backend choice. Fewer teams rewrote stacks to chase trends.

5. Full-stack expectations increased: Frontend-only roles declined by ~20% while demand grew for developers who understand APIs, backend logic, and infra basics.

6. DevOps knowledge becomes expected: CI/CD, deployment, monitoring, and cloud basics are no longer “extra skills.”

7. The job market stayed strong, but Selective: Around 1.5M openings, but fewer junior-friendly roles. Mid and senior engineers benefited most.

8. Backend stayed boring: Node.js kept its lead (~50%). Rust and WebAssembly gained attention, but mostly for specific performance cases.

9. Costs became visible: Cloud and infra bills forced teams to think about efficiency, not just speed. The efficiency gap widened.

10. The market grew - pressure grew faster: The global web dev market crossed $70B (+15% YoY). More work, higher expectations, tighter timelines.

What Looks Likely in 2026

1. AI agents handle routine work: Planning, refactoring, test generation, and scaffolding will be increasingly automated. Estimates suggest ~40% routine tasks.
Prepare for: Reviewing and guiding AI, not fighting it.

2. Developers move closer to system design: Less focus on syntax mastery. More focus on architecture, constraints, and decisions.
Prepare for: Explaining why, not just how.

3. WebAssembly grows quietly: Used selectively for speed-critical paths, not full rewrites. High-performance code and new languages (Rust, Go) will shine.
Prepare for: Cross-language thinking.

4. Performance becomes a core skill: Caching, streaming, lazy loading, measurement-first optimization, and stability as business priorities.
Prepare for: Understanding bottlenecks end-to-end.

5. Cloud costs stay under pressure: Efficiency directly affects budgets and hiring decisions.
Prepare for: Cost-aware architecture.

6. Sustainability becomes enforced: Green hosting and energy-efficient systems move toward compliance, not marketing - 25% carbon cuts.
Prepare for: Lean systems.

7. Jobs continue growing: Demand moves toward ~2M roles, but AI, backend, and infra gaps stay open.
Prepare for: Continuous learning.

8. Roles blur further: Frontend, backend, and platform boundaries soften. Ownership matters more than labels. Full-stack + ownership > titles.
Prepare for: Flexible skill sets.

9. Fewer tools, deeper use: Teams reduce tool sprawl and standardize stacks. Standardized stacks dominate.
Prepare for: Mastery, not collecting tools.

10. Judgment becomes the differentiator: AI can generate code. Humans still own consequences. AI codes; humans own outcomes.
Prepare for: Thinking like an engineer, not a typist.

2026 Focus:

Use AI as leverage, not autopilot
Strengthen performance and system fundamentals
Understand backend, infra, and deployment basics
Design for cost and sustainability
Go deeper, not wider, with tools

2025 made us faster. 2026 will reward better thinkers.

Quick Poll

Will AI be part of your daily dev workflow by the end of 2026?
Yes / No / Not sure yet

Original Source:

Developer Data

References:

Smart Job Search System for Developers, Stop Randomly Applying

Rajon Dey — Sun, 09 Nov 2025 18:29:22 +0000

Most developers apply to hundreds of jobs… and still don’t land the right one.

They scroll through LinkedIn, Indeed, or remote job boards, sending CVs everywhere — hoping something sticks.

But if you ask them where they applied last week, what roles they’re targeting, or how many they plan to apply for next week — they have no idea.

They’re playing the random application lottery.

And honestly? That rarely works.

I’ve been there too — spending weeks applying aimlessly, wondering why I wasn’t getting callbacks.

Until I built a system.

A simple, step-by-step job search framework that finally made the process structured, trackable, and less stressful.

Today, I’ll share that exact system with you — the same one I personally use to track opportunities, stay consistent, and apply smarter, not harder.

And yes — I’ve created a free Notion template you can duplicate and start using right away (linked below).

Why Most Developers Fail the Job Search Game

Here’s the truth: job searching isn’t about luck, it’s about systems.

Developers understand systems better than anyone — yet when it comes to their own careers, most rely on randomness.

You wouldn’t deploy code without testing or tracking, right?

So why apply to jobs without a plan?

A job search is a project.

It needs structure, process, and feedback loops.

That’s what this system gives you.

Step 1: Build Your Job Apply System

Think of this as setting up your project environment.

Before you start coding, you need the right setup. Same here.

Ask yourself three key questions:

Where will you apply?

Choose 1–2 main platforms like LinkedIn, Wellfound, or RemoteOK. Too many platforms = chaos.
What kind of roles are you targeting?

Be specific — Frontend Engineer, Full Stack Developer, or React Developer. Precision helps your search engine (and your brain) focus.
Which countries or regions?

Remote? On-site relocation? A few target regions make the process much more intentional.

Once you define these clearly, your entire search feels lighter and more focused.

You stop scrolling endlessly and start identifying real opportunities that fit your goals.

It’s like adding the right filters to your API query — you instantly get better results.

Step 2: Define Your Target

“Any developer job” is not a goal — it’s confusion in disguise.

Clarity = power.

You need to know exactly what kind of position you’re going after.

Define your target in three dimensions:

Role: Frontend Engineer, Backend Developer, Full Stack, etc.
Level: Junior, Mid, Senior, or Lead.
Type: Remote, Hybrid, or Relocation.

Once you know your target, every application becomes intentional.

You’ll write sharper cover letters, tailor your CV faster, and feel more confident in interviews.

This clarity separates the average job seekers from the ones who get hired.

Step 3: Create Your Application Flow

Now, let’s get practical — how do you manage all this without burning out?

Here’s where most developers mess up: they try to collect job posts and apply and follow up — all at once.

That’s not efficient. It’s context-switching chaos.

Instead, use a Notion database to organize your flow.

Here’s how I do it:

Week 1: Collect job posts that match your filters (15–20 is good). Don’t apply yet.
Week 2: Apply to those collected jobs, track progress, and note replies.

This separation between collection and application is a game-changer.

It keeps your focus clean and your workflow consistent.

Because job hunting is a number game — but not about random numbers.

It’s about intentional quantity + consistent quality.

Track it weekly. See what works. Iterate like a developer.

Step 4: Prepare Your Resources

Before applying, make sure your assets are ready — just like preparing your dev setup before starting a project.

CV: Keep one master version, tweak slightly per job.
Cover Letter: Have a basic template ready; personalize where needed.
Q&A: Prepare answers for common questions — salary expectations, notice period, current projects, etc.
Optimization: Tailor your CV based on the company’s tech stack or requirements.

Preparation creates speed.

Once everything is set, applying feels like execution, not effort.

You don’t recompile your entire app every time you test one feature, right?

Same logic here — reuse, optimize, deploy faster.

Step 5: Bonus Tips That Give You an Edge

A few small habits can make a big difference.

Leverage your network:

Reach out politely to someone from the company. A referral message can lift your application to the top of the stack.
Show your work:

Share your GitHub, portfolio, or side projects. Even simple ones prove your capability better than words.
Know your worth:

Research salary ranges before applying. Developers often undersell themselves because they skip this step.
Communicate your value, not your tools:

Don’t just say, “I use React.” Say, “I built X feature that improved Y metric.”

Companies hire problem-solvers, not framework users.

Final Thoughts

So here’s your roadmap:

Build your system.
Define your target.
Create your flow.
Prepare your resources.
Apply with an edge.

If you follow this system, your job search stops being a guessing game and becomes a process you can actually manage, track, and improve.

It’s not about applying everywhere — it’s about applying smartly.

⚙️ Get the Free Template

I’ve created a Smart Job Tracker (Notion Template) you can duplicate instantly.

It’s simple, clean, and designed for developers who want to take control of their job search.

👉 Duplicate the Template Here

If you found this useful, subscribe to Developer Data — where I share systems, strategies, and resources that help developers grow smarter in their careers.

Let’s stop random applying — and start building intentional systems that work.

Cloud & AI: The Inseparable Partners Shaping the Future.

Rajon Dey — Thu, 03 Jul 2025 10:08:25 +0000

In today’s fast-moving digital world, one truth is becoming clearer than ever:

Cloud and AI are no longer just complementary—they are truly inseparable partners shaping our future.

From the way we build apps to the way we process data, AI thrives on scale, and Cloud offers the infrastructure to make that scale a reality.

In fact, Gartner predicts 50% of cloud compute resources will be devoted to AI workloads by 2029, up from less than 10% today. [Gartner, 2025]

This isn’t a coincidence—it's an evolution. Cloud fuels AI’s growth, and AI accelerates cloud adoption.

Building the Cloud Foundation for an AI-Driven Future

To better understand this convergence, I’ve been diving deep into AWS Educate, exploring the core services that empower AI and data workflows.

Here are the foundational courses I’ve completed in the last month:

🗃️ Getting Started with Databases
Learn how cloud-native databases handle massive volumes of structured and unstructured data.

🌐 Getting Started with Networking
Understand global communication between AI services and data sources securely and efficiently.

🖥️ Getting Started with Compute
Explore the engines behind AI model training—EC2, Lambda, and container services.

🗄️ Getting Started with Storage
Discover where and how models, datasets, and logs are stored, accessed, and optimized.

☁️ Introduction to Cloud 101
A big-picture overview of how cloud services operate, scale, and secure digital workloads.

You can check out all my verified badges on Credly.

How It Ties Back to AI

Let’s be real: Training an AI model on your laptop won’t take you far. You need compute power, flexible storage, versioning, secure APIs, distributed databases—exactly what the Cloud is designed for.

Whether it's:

Hosting LLMs on serverless GPU-powered containers,
Streaming real-time data for inference through cloud-based pipelines,
Or leveraging tools like SageMaker, Bedrock, and Lambda for AI orchestration—

Cloud infrastructure isn’t optional anymore. It’s AI’s best friend.

Forrester echoes this, stating, "Your Cloud Strategy Is Your AI Strategy, Too," underscoring that the proliferation of generative AI is leading to the rise of the "AI-native cloud" where intelligence transforms every aspect of public cloud data centers. [Source: Forrester, "Embrace The AI-Native Cloud Now," May 2025]

Developer Takeaway

If you're stepping into AI, don’t ignore the cloud.

If you're a cloud developer, now is the best time to get AI-fluent.

Start small. But stay consistent. These AWS Educate courses were free and beginner-friendly, just like a solid warmup before lifting heavy AI models.

“In the AI age, Cloud isn’t just infrastructure—it’s empowerment.”

Let’s keep building, keep learning, and keep evolving with this unstoppable tech duo.

📬 This post is part of the Developer Data newsletter — bite-sized deep dives in development topics.

👉 Subscribe here 👉 Follow me on Threads

Stay tuned for more insights in the next issue of Development Industry.

Catch you in the next thought! 👋

Git Commands & Workflows: Most of Us(Devs) Never/Rarely Use!

Rajon Dey — Tue, 06 May 2025 19:25:03 +0000

A compact deep dive into the power of Git & GitHub

🗂 Table of Contents

Intro: Snapshots, Not Diffs
Git Workflows: Find Your Flow
Git Internals: Inside Git’s Brain
Rare Used Git Commands: Commands You (Should) Use
1. Debugging with Git: Trace, Hunt & Find
2. Visualizing Git: See the Tree, Not Just the Leaves
3. Rewriting History: Be Careful, But Powerful
4. Advanced Branching: Level Up Your Git Skills
GitHub Power-Ups: Supercharge Your Repo
Git Stats: Numbers Behind this
Pro Tips & Aliases: Efficient with Your Git Flow
Resources to Master Git: Tools and Practice
Final Thoughts: Go Beyond Just Using Git

Understanding Git is easier when you stop thinking of it as just commands, and start visualizing it as:

A snapshot-based system (not diff-based)
A tree of commits connected by references
Local vs Remote: You have your repo, and the origin (remote copy)

Think of HEAD as your camera view. Commits as photos, and branches as your album names.

👉 So when we say Git is snapshot-based, not diff-based, we mean: Git saves the full content of files (with optimization for unchanged files), instead of just the changes (diffs).

🚦 Git Workflows – Quick Overview

Git Flow: main + develop + feature/hotfix/release branches — great for large, structured teams.
GitHub Flow: main + short-lived feature branches — ideal for fast-paced, continuous delivery.
Trunk-Based: Single main branch with rapid CI/CD — best for small teams or modern DevOps.
Feature Toggles: Use flags to deploy incomplete features — avoid long-lived branches.
Forking Model: Contributors fork, then PR — perfect for open-source collaboration.

💡 Long-lived branches = merge nightmares. Keep branches short-lived and focused.

🌍 Remote Repos: `origin` vs `upstream`

origin → Your repo's default remote (usually the one you cloned)
upstream → The original source repo you forked from (common in open source)

git remote add upstream <https://github.com/original/repo.git>
git fetch upstream
git rebase upstream/main

🎯 Use origin to push your changes. Use upstream to stay synced with the original repo.

🧬 Git Internals (Simplified)

Git stores everything as objects:
- blob = file contents
- tree = folder structure
- commit = snapshot + metadata
- tag = reference to a commit
.git/ folder = your repo's entire brain (history, objects, refs)
SHA-1 hashes = unique IDs for commits — Git is content-addressable and immutable

🧠 Understand the plumbing (like git cat-file, git hash-object) to debug weird issues or build Git-based tools.

Essential Yet Unused Git Commands

These commands are like developer superpowers—rarely used, but incredibly useful when wielded right.

🧰 Workflow Utilities

Speed up daily Git tasks with smart shortcuts and hidden gems.

Command	What it Does	When to Use It
`git stash`	Temporarily shelves uncommitted changes	You need to switch branches without committing junk
`git stash pop`	Reapplies stashed changes	Once you're ready to resume your previous task
`git cherry-pick <commit>`	Applies a specific commit from one branch to another	When you want just that one fix
`git switch <branch>`	Switches branches (modern alt to `checkout`)	For cleaner, intuitive branch management
`git clean -fd`	Removes untracked files and dirs	When your repo feels messy and full of temp files

🧪 Debug & Investigate

Hunt bugs, trace changes, and understand who did what, when, and why.

Command	What it Does	When to Use It
`git bisect`	Finds the commit that introduced a bug using binary search	Bug appeared somewhere between two commits—find the culprit fast
`git blame <file>`	Shows who changed what and when	Understand context behind a line of code
`git show <commit>`	Displays changes from a specific commit	Review exactly what a commit did
`git log -S'someCode'`	Search commit history for code changes	Find when a specific piece of code was added/removed

🧠 Git is not just version control—it's a time machine for code clarity.

📜 Visualizing History

See your project’s evolution at a glance—structure beats scrolling.

Command	What it Does	When to Use It
`git log --graph --oneline --all`	Visual tree of all branches and commits	Quickly understand the branch structure
`git reflog`	Shows every move your HEAD made	Recover a lost commit or undo that “oops” moment
`git diff`	View changes between commits, branches, or the working directory	For side-by-side comparisons
`git shortlog -sn`	Lists commit count per contributor	Handy for stats or code ownership insight

✍️ Rewriting History (Use with care)

Rewriting history can clean things up—but on local branches only unless you know what you're doing.

Command	What it Does	Use it for...
`git commit --amend`	Modify the last commit (message or staged files)	Fix typos or add missed changes
`git rebase -i HEAD~n`	Interactively squash, reorder, or edit past commits	Cleanup commit history before pushing
`git reset --soft HEAD~1`	Undo last commit but keep changes staged	Rephrase your commit message
`git reset --hard HEAD~1`	Completely erase last commit and changes	Only when you're absolutely sure!
`git revert <commit>`	Creates a new commit that undoes the changes	Safely “undo” a pushed commit on shared branches

⚠️ Never rebase, reset, or amend on shared branches without team consent. Breaks shared history = chaos.

🔄 Advanced Branching Strategies (Optional Add-on)

Command	What it Does	Why Use It
`git worktree add <dir> <branch>`	Checkout multiple branches simultaneously in separate folders	Ideal for testing or parallel dev work
`git merge --squash`	Combine all changes into one commit without actual merge	Clean history from feature branches before merging
`git remote prune origin`	Cleans up old remote-tracking branches	Helps keep your local repo tidy

🚀 GitHub Superpowers

GitHub CLI (gh) – Manage PRs, issues, and repos straight from your terminal

→ gh pr create, gh issue list
Actions – Automate CI/CD with YAML workflows

→ Build, test, deploy on push or PR
Secrets – Securely store API keys and tokens for automation
Packages – Host Docker, npm, Maven packages right from your repo
Projects & Discussions – Lightweight tools for planning and collaboration

⚡ Pro Tip: Combine Actions + CLI + Secrets = DevOps magic inside your repo.

Git & GitHub Stats (with Sources)

Metric	Value	Source
Git Commands	150+ total (20 used daily)	Git Docs
GitHub Users	100M+ (as of 2024)	GitHub Blog
Repositories Hosted	420M+	Wikipedia
Commits Per Day	35M+	Coinlaw
GitHub Actions (Daily Runs)	4M+	GitHub Changelog
Annual Revenue	$1B+ (ARR)	CNBC
GitHub Employees	~5,600 (2024)	Wikipedia

⚙️ Pro-Level Git Tips & Aliases

Add these to your ~/.gitconfig to speed up common commands:

[alias]
  co = checkout
  br = branch
  st = status
  lg = log --oneline --graph --decorate --all

🔧 Config Tweaks for Better Dev Flow

Auto-correct typos

→ git config --global help.autocorrect 1
Use VS Code as default editor

→ git config --global core.editor "code --wait"
Colorful CLI output

→ git config --global color.ui auto

💡 Tip: Use aliases like git lg to visualize your branch history at a glance

Learning Resources & Tools to Level Up

⚒️ Visual Git Tools

Tools like GitKraken, Sourcetree, GitHub Desktop can help you understand Git flow visually.
Ideal for visual learners or for onboarding junior devs.

🧠 Practice Tools

learngitbranching.js.org – Interactive visualization of Git commands.
OhMyGit! – A game to learn Git.
Git Workflows – Understand Gitflow, trunk-based, GitHub Flow, etc.

Disclosure

Crafted with deep questions, multiple AI chats, lots of Googling, real-world Git practice, and verified through trusted docs. Still learning. Still refining.

🎯 Final Thoughts

Most developers use Git.
Fewer truly understand it.
Only a few actually leverage its full power.

Mastering Git isn’t about memorizing commands—it's about learning how Git thinks. Once you understand the internal model, embrace smart workflows, and tap into GitHub’s hidden superpowers, you’ll go beyond just writing code—you’ll collaborate, debug, and deliver like a pro.

📬 Like insights like this?

This post is part of the Developer Data newsletter — bite-sized deep dives into the tools you use every day but rarely master.

👉 https://developer-data.beehiiv.com/subscribe

👉 https://www.threads.com/@rajjon.dey

👉 Save it as your Git cheatbook

Happy Coding! See you in the next deep dive. ✌️

🔐 Session Token vs Refresh Token — The Simplest Explanation!

Rajon Dey — Tue, 15 Apr 2025 15:23:37 +0000

Modern web apps run on tokens. But which one does what? Let's break down Session Tokens and Refresh Tokens so clearly that you’ll never forget, and confidently implement them in any project.

Let’s go from concept to code and build your solid understanding with:

🔧 What to Build (Token System Essentials)
📜 Functions You’ll Need
🔁 Algorithms/Flows
🛠️ Tools & Libraries (with alternatives)
🚀 Trendy/Best Practices
🏢 What Big Tech Uses

🔧 1. WHAT TO BUILD – Token Auth System in Any App

Any software (web, mobile, API-based) with token authentication will have 3 main parts:

Step	Action
🔐 1	Login (generate access + refresh tokens)
🔄 2	Refresh token (get new access token)
🔓 3	Logout (invalidate refresh token)

📜 2. REQUIRED FUNCTIONS (in pseudo + JS-style)

You typically need to write 5 core functions:

// 1. Login
function login(email, password) {
  // validate user
  // generate accessToken + refreshToken
  // store refreshToken securely (DB or cookie)
}

// 2. Generate Access Token
function generateAccessToken(user) {
  // return jwt.sign(user, secret, { expiresIn: '15m' })
}

// 3. Generate Refresh Token
function generateRefreshToken(user) {
  // return jwt.sign(user, refreshSecret, { expiresIn: '7d' })
}

// 4. Refresh Token Endpoint
function refresh(req) {
  // validate refreshToken
  // if valid => issue new accessToken
}

// 5. Logout
function logout(req) {
  // remove/invalidate refreshToken
}

Add:

✅ middleware to check access token on every API call
🔄 Token rotation strategy

🔁 3. ALGORITHM FLOW (Pseudocode)

A. Login Flow

User submits email + password
↓
If valid:
  → generate access token (15 mins)
  → generate refresh token (7 days)
  → send access in body, refresh in HTTP-only cookie

B. API Request Flow

Frontend sends access token in headers
↓
Backend verifies token
↓
If valid → grant access
If expired → ask frontend to refresh token

C. Token Refresh Flow

Frontend sends refresh token (cookie)
↓
Backend verifies it
↓
If valid → issue new access token (maybe refresh token too)
↓
Frontend replaces old token and continues

D. Logout Flow

User clicks logout
↓
Frontend deletes tokens (cookie/localStorage)
↓
Backend blacklists or deletes refresh token from DB

🛠️ 4. TOOLS TO USE

🔑 Token Generator

jsonwebtoken (Node.js)
pyjwt (Python)
nimbus-jose-jwt (Java)

📦 Session Store (Optional)

Redis (store refresh token or blacklist tokens)
In-memory (for demo)
Database (Mongo, Postgres)

🍪 Cookie Management

cookie-parser (Node)
HttpOnly + SameSite=Strict for refresh tokens

🔐 Auth Libs (if you want ready-made)

NextAuth.js (Next.js)
Passport.js (Node)
Firebase Auth (Google, prebuilt solution)
Supabase Auth (Backendless)

⚡ 5. TRENDY BEST PRACTICES

✅ Use short-lived access tokens (15m to 1h)

✅ Use refresh tokens with rotation (and maybe detection of reuse)

✅ Store refresh token in HTTP-only secure cookies, never in localStorage

✅ Add a logout-all-devices or token revoke option

✅ Use middleware/auth guard in APIs/routes

✨ Extra: Use a queue (e.g., Redis) to store a blacklist of used refresh tokens (detect hijacking)

🏢 6. BIG TECH STRATEGY

Company	Auth System	Notes
Facebook	Session cookie-based (internal), tokens for APIs	Uses long-lived refresh system
Google	OAuth2 + OpenID + JWT	Access & Refresh tokens, stored securely
Discord	Access token + refresh token flow	Like OAuth2 spec
Spotify	Strict refresh token rotation, OAuth2	Modern best practices
Netflix	Short-lived access token, secure refresh handling	High emphasis on device-level auth

💬 Even big companies don't keep users logged in forever. They refresh tokens in the background to make UX smooth.

✅ What You Should Write (Almost Any Software Needs):

Backend

Login route
Token generation utilities
Token refresh route
Logout route
Auth middleware
Optional: Token storage in DB or Redis

Frontend

Store access token (memory/localStorage)
Auto-refresh tokens on expiration
Logout flow
Attach token to API headers

🧠 Side-by-Side Snapshot

Feature	Session Token (Access)	Refresh Token
Purpose	Access APIs	Get new access tokens
Lifespan	Short (15m–1h)	Long (days–weeks)
Sent with requests	✅ Yes	❌ No
Risk if stolen	High (frequently exposed)	Low (stored securely)
Storage	Memory/localStorage/cookie	HTTP-only cookie (preferred)
Rotation	❌ Optional	✅ Recommended

🎯 Quick Summary

Use access tokens for immediate API calls.

Use refresh tokens to silently renew access without asking the user to log in again.

Store refresh tokens securely. Rotate them. Invalidate them on logout.

Access token is your key to the house. Refresh token is your ability to get a new key if you lose the old one.

Trend Watch: Why Next.js 15 Is Google’s New Favorite Framework

Rajon Dey — Thu, 03 Apr 2025 15:57:04 +0000

For years, JavaScript frameworks have struggled with SEO. Google’s crawlers penalized slow hydration, ignored JavaScript-heavy pages, and tightened crawl budgets—making life difficult for sites built on React, Angular, or Svelte.

But something changed with Next.js 15.

Instead of fighting Google’s algorithm, it works with it—helping sites rank better, load faster, and get indexed more efficiently.

Let’s break down why Google actually likes this JavaScript framework—and what it means for you.

Google’s SEO Updates vs. JavaScript Sites

In 2024, Google’s ranking system got stricter:

🚨 INP (Interaction to Next Paint) is now a key metric

🚨 JavaScript-heavy sites get a lower crawl budget

🚨 Page experience plays a bigger role in rankings

For many frameworks, these changes made things worse.

But Next.js 15 found a way to use them to its advantage.

Here’s how.

The 3 Next.js 15 Features That Google Loves

1️⃣ Partial Prerendering (PPR) – Instant Content for Crawlers

Google’s biggest complaint about JavaScript frameworks?

Blank pages while hydration completes.

Next.js 15 fixes this with Partial Prerendering (PPR):

// next.config.js  

experimental: {  
  ppr: 'true' // Now stable  
}

So, it works like:

The page loads static HTML immediately
Dynamic content is streamed in later

*And it matters, because: *

Crawlers see real content instantly
No more "empty page" penalties

2️⃣ Auto-Generated Schema Markup – More Rich Snippets

SEO is more than just loading fast—Google also needs to understand your content.

Next.js 15 automates structured data so that your pages get better visibility in search results.

// app/product/[id]/page.tsx  

export default function Page() {  
  return (  
    <article>  
      <h1>Product</h1> {/* Auto-generates Product schema */}  
    </article>  
  )  
}

*And it does the followings: *

Detects the type of content (Product, BlogPost, etc.)
Fills in missing schema fields automatically
71% more rich snippets in beta testing

3️⃣ Intelligent ISR (iISR) – Smarter Crawl Budget Management

Google limits how often it crawls your site. If your important pages don’t get refreshed, your rankings can drop.

Next.js 15 introduces Intelligent Incremental Static Regeneration (iISR) to control what Google prioritizes.

// app/data/route.ts  

export const revalidate = {  
  priority: ['/deals'], // Googlebot gets fresh content  
  lazy: ['/archive']    // Older pages save crawl budget  
}

*And this helps, because: *

High-value pages update faster
Less important pages don’t waste crawl budget

Other Frameworks vs. Next.js 15

Most JavaScript solutions fail in at least one of these areas:

❌ React & Angular – Hydration delays content loading
✅ Next.js 15 – PPR ensures instant visibility

❌ SvelteKit – Requires manual svelte:head for SEO
✅ Next.js 15 – Auto-generates metadata

❌ Astro – Great for static sites but struggles with dynamic pages
✅ Next.js 15 – Balances static & dynamic content efficiently

How to Take Advantage of This

✅ Audit your site:

npx @next/bundle-analyzer
Check for client-side dependencies slowing down your load time.

✅ Enable Partial Prerendering (PPR):

// app/layout.js  
export const experimental_ppr = true

✅ Optimize Google’s crawl preferences:

Use priorityRevalidate for important pages

Let generateMetadata auto-handle SEO

Extra Tip: Googlebot prefers sites using Next.js 15’s navigation.preload. Enable it in next.config.js.

Final Thoughts

Even Google’s John Mueller admitted:

“We’re seeing significantly better indexing behavior with modern SSR implementations… when done right.”

Next.js 15 isn’t just another framework update—it’s a fundamental shift in how JavaScript sites work with Google instead of against it.

Want to test it yourself? Run an SEO audit before & after upgrading.

Steps to Set Up Virtual Host and MySQL for WordPress Development on Linux

Rajon Dey — Tue, 18 Mar 2025 09:59:10 +0000

Simple guide for setting up a virtual host and MySQL for WordPress development. This is tailored for Ubuntu/Debian-based distributions.

Steps to Set Up Virtual Host and MySQL for WordPress Development on Linux

1. Install Required Software

Update your system:

   sudo apt update && sudo apt upgrade -y

Install Apache, MySQL, and PHP:

   sudo apt install apache2 mysql-server php libapache2-mod-php php-mysql

2. Set Up MySQL Database

Secure MySQL installation:

   sudo mysql_secure_installation

Set a root password (if prompted).
Answer Y (yes) to all security questions.

   sudo mysql -u root -p

Create a database for WordPress:

   CREATE DATABASE wordpress_db;

Create a MySQL user and grant privileges:

   CREATE USER 'wordpress_user'@'localhost' IDENTIFIED BY 'your_password';
   GRANT ALL PRIVILEGES ON wordpress_db.* TO 'wordpress_user'@'localhost';
   FLUSH PRIVILEGES;
   EXIT;

3. Configure Virtual Host

Create a directory for your WordPress site:

   sudo mkdir -p /var/www/yourdomain.com

Set permissions:

   sudo chown -R $USER:$USER /var/www/yourdomain.com

Create a virtual host configuration file:

   sudo nano /etc/apache2/sites-available/yourdomain.com.conf

Add the following content:

   <VirtualHost *:80>
       ServerName yourdomain.com
       DocumentRoot /var/www/yourdomain.com

       <Directory /var/www/yourdomain.com>
           AllowOverride All
       </Directory>

       ErrorLog ${APACHE_LOG_DIR}/error.log
       CustomLog ${APACHE_LOG_DIR}/access.log combined
   </VirtualHost>

Enable the site and reload Apache:

   sudo a2ensite yourdomain.com.conf
   sudo systemctl reload apache2

4. Install WordPress

Download WordPress:

   cd /tmp && wget https://wordpress.org/latest.tar.gz

Extract WordPress to your site directory:

   sudo tar -xvzf latest.tar.gz -C /var/www/yourdomain.com --strip-components=1

Set permissions:

   sudo chown -R www-data:www-data /var/www/yourdomain.com

5. Configure WordPress

Open your browser and go to http://yourdomain.com.
Follow the WordPress setup wizard:
- Database Name: wordpress_db
- Username: wordpress_user
- Password: your_password
- Database Host: localhost
- Table Prefix: wp_ (default)
Complete the installation.

6. Test Your Setup

Visit http://yourdomain.com to see your WordPress site.
Log in to the WordPress admin dashboard at http://yourdomain.com/wp-admin.

Optional: Local Domain Setup

If you’re working locally, edit your /etc/hosts file to map yourdomain.com to 127.0.0.1:

Open the hosts file:

   sudo nano /etc/hosts

Add this line:

   127.0.0.1   yourdomain.com

Save and exit.

Summary

Installed Apache, MySQL, and PHP on Linux.
Created a MySQL database and user.
Set up a virtual host for your domain.
Installed and configured WordPress.

You’re now ready for WordPress development on Linux! 🚀

NextLib: 10+ Most Used Features for Developers

Rajon Dey — Tue, 04 Mar 2025 15:45:30 +0000

Are you reinventing the wheel in every project?

The same challenges across projects — be it handling authentication, implementing pagination, or managing forms. Imagine having a go-to guide with ready-to-use solutions for these tasks!

In this post, I’ll share you 10 Repetitive building blocks that every developer needs, complete with easy-to-follow steps and links to live code snippets. Let’s make your next project faster, smoother, and more efficient!

I'm building it from last 10 days for you!

Here is the list of features, which you repeat in most of your projects:

Authentication - Secure login, signup, forgot password, and dashboard
Pagination - Navigate datasets with prev/next and page numbers
Search Filters - Filter data with text search and category dropdowns
Data Table - Show data in rows
Data Grid - Combines pagination, search, and tables
Form Validation - Handle forms with real-time validation
Notifications/Toasts - Show success, error, or info messages
File Upload - Upload files with size and type validation
Modals/Dialog - Popups for forms, alerts, or content
Menu with Dropdowns - Responsive navigation with dropdown submenus
Loading States - Skeleton placeholders for a polished loading experience

1. Authentication

Why? Lock down your app with style—login, signup, and password resets.

Algorithm:

Whipped up forms for login, signup, and reset.
Added input checks and sent data to a mock API.
Stashed the token in local storage.
Zipped users to a dashboard on success.

Source code: GitHub

2. Pagination

Why? Big lists need breaking up—keep it user-friendly.

Algorithm:

Fetched data in chunks with page controls.
Built prev/next buttons and numbered links.
Swapped pages seamlessly with state.

Source code: GitHub

3. Search Filters

Why? Let users dig through data fast.

Algorithm:

Crafted a search bar and category dropdown.
Filtered results on the fly as users typed or picked.
Kept it snappy and simple.

Source code: GitHub

4. Data Table

Why? Show off data in neat rows—tables never go out of style.

Algorithm:

Designed a table with custom columns.
Populated it with dummy data (swap yours in!).
Made it clean and adaptable.

Source code: GitHub

5. Data Grid

Why? Combine pagination, search, and tables for a powerhouse.

Algorithm:

Mixed my pagination, filters, and table into one.
Managed state to keep everything in sync.
Delivered a ready-to-roll data solution.

Source code: GitHub

6. Form Validation

Why? Forms that catch mistakes save headaches.

Algorithm:

Used react-hook-form for controlled inputs.
Added rules like “required” and “valid email.”
Showed errors live as users typed.
Handled submissions with a cheer.

Source code: GitHub

7. Notifications/Toasts

Why? Quick feedback keeps users in the loop.

Algorithm:

Created a toast system with success/error/info types.
Set them to pop up and fade after a bit.
Added a close button for control.

Source code: GitHub

8. File Upload

Why? Users need to send files—make it painless.

Algorithm:

Built a drop zone with size and type checks.
Showed errors if files didn’t fit the rules.
Listed uploads for confirmation.

Source code: GitHub

9. Modals/Dialogs

Why? Pop-ups for forms or alerts—handy every time.

Algorithm:

Designed a modal that opens and closes smooth.
Added a title bar and click-outside-to-close.
Packed it with flexible content space.

Source code: GitHub

10. Menu with Dropdowns

Why? Navigation that works on any screen is a must.

Algorithm:

Crafted a menu with dropdown subitems.
Made it collapse into a hamburger on mobile.
Kept it slick and responsive.

Source code: GitHub

11. Loading States

Why? Skeletons beat a blank screen while data loads.

Algorithm:

Built a loader with pulsing skeleton rows.
Let you tweak sizes for custom fits.
Swapped to content when ready.

Source code: GitHub

Sneak Peek:

Live link - https://nextlib-rajon.vercel.app/

Get Involved! 🌟

Check out the full library on GitHub: NextLib.

Star it: If you find it useful, a ⭐ keeps me motivated!
Stay Tuned: I’ll be adding more features and updates—until then!

These 10 pieces are my gift to streamline your projects.

These 10 essential features cover key aspects of development that almost every project needs. By using these simple approaches, you can save valuable time and effort. Don’t forget to bookmark this post for your next project! Which task would you like me to explore in more detail? Let me know in the comments and stay tuned for more practical tips in the next edition of Developer Data.

Happy coding!

10 Things I’ve Cared About AI.

Rajon Dey — Mon, 07 Oct 2024 09:50:45 +0000

AI won’t take your job; someone using AI will. And most likely, it'll be you replacing your old self by using AI.

"In ten years, almost every writer will have AI as a regular part of their workflow."
"Knowing AI doesn’t mean you’ll become successful overnight." It’s a tool, not magic.
"Some love AI, some hate it, but most people either don’t care or don’t know enough yet."
"People still value the human touch; AI content on its own feels cold and can only trick people for so long."
"To get good at AI, you need to: (1) stay curious, (2) experiment with the tools, and (3) be open to changing your perspective when AI surprises you."
"Your understanding of AI will evolve, and that's perfectly okay."
"AI doesn’t eliminate creativity; it pushes you to be more creative in new ways."
"It’s not about AI replacing humans—it’s about humans doing more with AI."
"The real strength is knowing when to rely on AI and when to trust your own instincts."
"The future isn’t AI or humans—it’s AI with humans working better together."

Join Developer Data, a blog for developer by developer!

7 Useful Vanilla JS Projects for Practice!

Rajon Dey — Tue, 01 Oct 2024 11:05:49 +0000

As a modern-age web developer, JavaScript is an essential part of your toolkit, and what better way to strengthen your skills than by building real projects with raw Vanilla JS?

I created a playlist called "7 Useful JS Projects," featuring practical challenges that will help you grasp JavaScript fundamentals while building something useful. Whether you’re a beginner looking to practice or an intermediate dev sharpening your skills, these projects offer great practice and learning opportunities.

Features:

Hands-on Learning: Build real and useful projects to reinforce JavaScript concepts.
Vanilla JS Focus: Master core JavaScript without relying on frameworks.
Diverse Skill Set: Cover API integration, DOM manipulation, CRUD operations, and more.
Portfolio Enhancement: Add seven impressive projects to showcase your abilities.
Practical Application: Learn techniques applicable to real-world development scenarios.

Here you go!

1. New Year Countdown:

A countdown timer that dynamically updates for upcoming New Year’s Eve!

2. GitHub Profile Search:

Fetch user data from the GitHub API and display profile information like followers, repositories, and more. This is a simple way to kickstart API handling.

3. BMI Calculator:

Develop a BMI calculator that takes user inputs (weight and height) and computes the Body Mass Index.

4. Password Generator:

Create a tool that generates secure, random passwords based on user criteria like length and character types.

5. Lyric Searcher:

Implement a lyrics search feature by integrating with a lyrics API. It’s a fun way to practice API requests, especially handling search queries.

6. Typing Speed and Accuracy Checker:

Measure typing speed with real-time feedback on words per minute (WPM). This project helps refine skills around timing functions and event listeners.

7. ToDo App:

Build a classic to-do list where users can add, delete, and manage tasks. It’s a simple but powerful project to master CRUD (Create, Read, Update, Delete) operations.

Each project was selected for its relevance and practical use in everyday web development, and all are created with plain Vanilla JS—no frameworks, just pure JavaScript. By the end of this series, you’ll have polished your skills and built a foundation to tackle even more complex projects in the future.

Check out the live preview and full playlist to start coding and boost your JavaScript confidence!

7 types of Database - which one you should pick?

Rajon Dey — Wed, 25 Sep 2024 11:01:20 +0000

Choosing the right database is a critical decision for any application or business. The database you select can significantly impact the performance, scalability, and reliability of your application. It can also influence development time and operational costs. With the wide variety of databases available today, understanding their unique strengths and use cases is essential to make an informed choice.

Databases are broadly categorized into two main types: Relational (SQL) and NoSQL. However, within these categories are specialized databases designed to handle specific types of data and workloads. This article will provide an overview of the different types of databases, including:

1. Relational (RDBMS): Structured tables, SQL queries (MySQL, PostgreSQL)

2. NoSQL:

Document: JSON-like documents (MongoDB)
Key-Value: Fast lookups (Redis)
Column-Family: Column-oriented storage (Cassandra)
Graph: Nodes and relationships (Neo4j)

3. NewSQL: SQL features with NoSQL scalability (Google Spanner)

4. Time-Series: Optimized for time-stamped data (InfluxDB)

5. Distributed: Data across multiple locations (Amazon Aurora)

6. Multimodel: Support multiple data models (ArangoDB)

7. In-Memory: Data in RAM for fast access (Redis)

Relational Databases (RDBMS)

Relational databases (RDBMS) are like organized filing cabinets, where data is stored in structured tables with rows and columns. This structure makes it easy to retrieve and manage data efficiently. Examples of RDBMS include MySQL, PostgreSQL, and Oracle.

Examples: MySQL, PostgreSQL, Oracle

Strengths:

Structured data organization
ACID compliance
Complex query capabilities
Strong data integrity

Best for:

Applications needing data consistency
Complex reporting and analytics
Well-structured data requirements
Legacy system compatibility

Ideal for critical applications requiring reliable transactions and organized data management.

NoSQL Databases

NoSQL databases offer flexible, scalable solutions for diverse data types and high-volume applications. They're categorized into four main types:

Categories and Examples:

Document Stores: MongoDB, CouchDB
Key-Value Stores: Redis, DynamoDB
Column-Family Stores: Cassandra, HBase
Graph Databases: Neo4j, ArangoDB

Strengths:

Flexible schema
High scalability
Efficient handling of large data volumes
Specialized for specific data models

Best for:

Applications needing rapid scalability
Handling unstructured or semi-structured data
High-performance, low-latency operations
Complex data relationships

Ideal for modern, data-intensive applications requiring flexibility and rapid scaling.

NewSQL Databases

NewSQL databases combine SQL's ACID compliance with NoSQL's scalability.

Examples: Google Spanner, CockroachDB

Strengths:

ACID compliance with horizontal scalability
High performance for large-scale transactions
Global distribution capabilities
Strong consistency in distributed environments

Best for:

Applications needing both consistency and scalability
High-volume transactional systems
Globally distributed operations
Real-time analytics on large datasets

Time-Series Databases

Time-series databases specialize in handling time-stamped data efficiently.

Examples: InfluxDB, TimescaleDB

Strengths:

Optimized for time-based data storage and retrieval
Efficient handling of large volumes of time-stamped data
Advanced time-based analytics and aggregation capabilities
Scalable for high write and query loads

Best for:

IoT sensor data management
Financial market data analysis
Server and application monitoring
Real-time analytics on time-based data

Ideal for applications requiring efficient storage, retrieval, and analysis of time-stamped data at scale.

Distributed Databases

Distributed databases store data across multiple servers or locations for high availability and scalability.

Examples: Amazon Aurora, Google Bigtable

Strengths:

High availability and fault tolerance
Easily scalable by adding more servers
Automatic data replication across nodes
Suitable for large-scale, global applications

Best for:

Mission-critical applications requiring constant uptime
Rapidly growing platforms with fluctuating demand
Applications needing data distribution across geographic regions
Systems requiring robust disaster recovery capabilities

Ideal for large-scale applications demanding high availability, fault tolerance, and seamless scalability across multiple locations.

Graph Databases

Graph databases store data as nodes and edges, optimizing for complex relationships.

Examples: Neo4j, OrientDB

Strengths:

Efficient handling of complex data relationships
High performance for traversing connected data
Flexible schema for dynamic data models
Powerful querying capabilities for relationship-based data

Best for:

Social networks and connection analysis
Recommendation engines
Fraud detection systems
Knowledge graphs and semantic webs

Ideal for applications where understanding and querying relationships between data points is crucial.

Multimodel Databases

Multimodel databases support multiple data models within a single database system.

Examples: ArangoDB, OrientDB

Strengths:

Support for multiple data models (document, graph, key-value)
Versatile data handling capabilities
Simplified architecture by reducing multiple database needs
Scalability and flexibility for evolving applications

Best for:

Applications requiring diverse data model support
Complex systems needing unified data management
Projects aiming to reduce database complexity
Evolving applications with changing data requirements

Ideal for applications needing flexibility to handle various data types and models in a unified, adaptable solution.

Selecting the right database is crucial for project success, like choosing the perfect tool for a specific job.

Key factors to consider:

Scalability: Can it grow with your application?
Performance: Does it meet speed requirements?
Consistency vs. Availability: Which is more critical?
Cost: Upfront and ongoing expenses
Ecosystem and Support: Available tools and community
Specific Use Cases: Alignment with data needs

Careful evaluation ensures optimal performance and scalability.

Final Words

Thank you for exploring the world of databases with us. We hope this guide aids your decision-making process and empowers your next project. Happy building!

DEV Community: Rajon Dey

The Complete Software Development Flow: From Idea to Production

0. Idea Foundation

1. Planning & Design

2. Backend Development

3. Frontend Development

4. Integration

5. Security & Optimization

6. Testing & QA

7. Deployment

8. Post-Launch

Developers: 2025 Was About Speed. 2026 Is About Judgment.

What Actually Happened in 2025

What Looks Likely in 2026

2026 Focus:

Quick Poll

Original Source:

References:

Smart Job Search System for Developers, Stop Randomly Applying

Why Most Developers Fail the Job Search Game

Step 1: Build Your Job Apply System

Step 2: Define Your Target

Step 3: Create Your Application Flow

Step 4: Prepare Your Resources

Step 5: Bonus Tips That Give You an Edge

Final Thoughts

⚙️ Get the Free Template

Cloud & AI: The Inseparable Partners Shaping the Future.

Building the Cloud Foundation for an AI-Driven Future

How It Ties Back to AI

Developer Takeaway

Git Commands & Workflows: Most of Us(Devs) Never/Rarely Use!

🗂 Table of Contents

🚦 Git Workflows – Quick Overview

🌍 Remote Repos: origin vs upstream

🧬 Git Internals (Simplified)

Essential Yet Unused Git Commands

🧰 Workflow Utilities

🧪 Debug & Investigate

📜 Visualizing History

✍️ Rewriting History (Use with care)

🔄 Advanced Branching Strategies (Optional Add-on)

🚀 GitHub Superpowers

Git & GitHub Stats (with Sources)

⚙️ Pro-Level Git Tips & Aliases

🔧 Config Tweaks for Better Dev Flow

Learning Resources & Tools to Level Up

⚒️ Visual Git Tools

🧠 Practice Tools

🎯 Final Thoughts

📬 Like insights like this?

🔐 Session Token vs Refresh Token — The Simplest Explanation!

🔧 1. WHAT TO BUILD – Token Auth System in Any App

📜 2. REQUIRED FUNCTIONS (in pseudo + JS-style)

🔁 3. ALGORITHM FLOW (Pseudocode)

A. Login Flow

B. API Request Flow

C. Token Refresh Flow

D. Logout Flow

🛠️ 4. TOOLS TO USE

🔑 Token Generator

📦 Session Store (Optional)

🍪 Cookie Management

🔐 Auth Libs (if you want ready-made)

⚡ 5. TRENDY BEST PRACTICES

🏢 6. BIG TECH STRATEGY

✅ What You Should Write (Almost Any Software Needs):

Backend

Frontend

🧠 Side-by-Side Snapshot

🎯 Quick Summary

Trend Watch: Why Next.js 15 Is Google’s New Favorite Framework

The 3 Next.js 15 Features That Google Loves

1️⃣ Partial Prerendering (PPR) – Instant Content for Crawlers

2️⃣ Auto-Generated Schema Markup – More Rich Snippets

3️⃣ Intelligent ISR (iISR) – Smarter Crawl Budget Management

Other Frameworks vs. Next.js 15

How to Take Advantage of This

Final Thoughts

Steps to Set Up Virtual Host and MySQL for WordPress Development on Linux

🌍 Remote Repos: `origin` vs `upstream`