DEV Community: Karan

🚀 Built a Cross-Database(AI) Recommendation System using FDW + Prisma

Karan — Fri, 27 Mar 2026 13:40:23 +0000

Recently worked on an interesting backend problem — sharing the approach in case it helps others working with multi-DB systems 👇

🧩 Problem

We had two separate databases:

Core DB → transactional data (activities, participants, items)
Profile DB → user/entity master data + metadata

We needed:
👉 A unified dataset for ranking/recommendation
👉 Without duplicating data across databases

💡 Solution: PostgreSQL FDW

Used Foreign Data Wrapper (FDW) to query Profile DB directly from Core DB.

CREATE EXTENSION postgres_fdw;

CREATE SERVER remote_profile_srv
FOREIGN DATA WRAPPER postgres_fdw
OPTIONS (
  host 'host',
  dbname 'profile_db',
  port '5432'
);

🔗 Foreign Tables

Mapped remote tables into local DB:

fdw_schema.entities
fdw_schema.entity_details
fdw_schema.entity_context

👉 Important: Convert enums → text to avoid cross-DB type issues.

🧠 Data Layer Design

Built 4 layered views:

1️⃣ entity_profile_view

Entity + metadata + classifications
Handles JSON structures (like category mappings)

2️⃣ activity_base_view

Core activities + configurations + rules
Pivot configs using:

BOOL_OR(...)  -- instead of MAX(boolean)

3️⃣ item_aggregation_view

Extracts dynamic JSON fields
Aggregates quantities, values, etc.

4️⃣ entity_activity_master_view (🔥 final)

Joins everything
Output = activity × entity dataset

⚙️ Challenge: Prisma + ENV in SQL

Prisma migrations don’t support .env inside SQL ❌

✅ Fix

Used a custom Node script to inject env values:

const finalSQL = sql
  .replace(/__HOST__/g, process.env.DB_HOST)
  .replace(/__DB__/g, process.env.DB_NAME);

Then executed via pg client.

🏗️ Final Architecture

Profile DB
   ↓ (FDW)
Core DB (views)
   ↓
entity_activity_master_view
   ↓
Ranking / ML / APIs

⚡ Key Learnings

FDW is powerful for real-time cross-DB joins
Always cast enums → text
Use BOOL_OR instead of MAX(boolean)
Prisma needs custom migration handling
Views help create a clean analytical layer

🎯 Use Cases

Recommendation systems
Ranking engines
Analytics without ETL pipelines

🔥 Takeaway

You don’t always need:
❌ data duplication
❌ complex ETL pipelines

Sometimes:
👉 FDW + smart SQL views = a clean and scalable solution

If you're working on distributed data systems or recommendation problems, this approach can be really useful.

Happy to discuss more 🤝

postgres #nestjs #prisma #backend #sql #architecture

🚀 Build a Powerful Developer Portfolio & Resume Using AI (Step-by-Step Guide)

Karan — Mon, 16 Feb 2026 07:33:12 +0000

AI is no longer just a buzzword — it’s your personal career assistant.

If you’re a developer and not using AI to build your portfolio and resume, you’re honestly missing out.

In this post, I’ll show you how to:

✅ Create a stunning portfolio using AI
✅ Use Lovable AI efficiently (even on free tier)
✅ Generate a professional LaTeX resume using ChatGPT / Claude
✅ Stand out in a competitive dev market

Let’s get started 👇

🌐 Part 1: Creating a Developer Portfolio Using AI

Step 1️⃣ – Define Your Portfolio Strategy (Use ChatGPT / Claude)

Before jumping into tools, define:

Your tech stack
Your years of experience
Your niche (Frontend / Backend / Full Stack / AI / DevOps etc.)
Your unique selling point

Example prompt:

Act as a senior tech recruiter. 
Help me structure a modern portfolio for a Full Stack Developer with 3+ years of experience in Java, Spring Boot, Angular and Microservices. 
Make it recruiter-friendly and impactful.

AI will give you structure like:

Hero Section
About Me
Skills
Projects
AI Usage in Work
Experience
Contact

Step 2️⃣ – Build Portfolio Using Lovable AI

Lovable AI is amazing for quickly building clean, modern portfolios.

🔥 Important (For Free Tier Users)

If you’re using the free plan:

Avoid multiple small prompts.
Give one detailed master command.
Be very specific.
Structure everything in a single instruction.

Example Master Command

Create a modern, minimal, dark-themed portfolio website.

Sections:
1. Hero section with name, title: Full Stack Developer (Java + Angular)
2. About section highlighting 3+ years experience in building scalable web apps
3. Skills section categorized into:
   - Backend: Java, Spring Boot, Microservices
   - Frontend: Angular, TypeScript, HTML, CSS
   - Database: PostgreSQL, MySQL
4. Projects section with 3 detailed enterprise-level projects
5. Section explaining how I use AI tools in daily development
6. Contact section with LinkedIn and GitHub placeholders

Use smooth animations, clean typography, responsive design and professional layout.

💡 Pro Tip:
You can ask ChatGPT or Claude to refine this command before giving it to Lovable AI.

Example:

Optimize this command for best output in Lovable AI free tier:
[paste your master command]

That way, AI helps you use AI better 😉

🤖 Add This Section to Stand Out

Most portfolios look the same.

Add a section like:

“How I Use AI in Daily Development”

Mention things like:

Code optimization
Debugging support
Writing unit tests
API documentation generation
Architecture suggestions
SQL query tuning

Recruiters LOVE practical AI usage.

📄 Part 2: Create a Professional Resume Using AI + LaTeX

Now let’s build a clean ATS-friendly resume.

Instead of Word templates, generate LaTeX code using:

ChatGPT
Claude

LaTeX resumes look clean, professional, and minimal.

🎯 Example Prompt (Full Stack Developer – Java + Angular)

You can use this directly:

Act as an expert resume writer and ATS specialist.

Create a professional one-page LaTeX resume for a Full Stack Developer with:

- 3+ years experience
- Backend: Java, Spring Boot, Microservices
- Frontend: Angular, TypeScript
- Database: PostgreSQL, MySQL
- Experience in REST APIs, authentication, role-based access
- Experience working in agile teams
- Experience integrating AI tools in daily development workflow

Include:
- Strong professional summary
- Technical skills section
- 3 impact-driven project descriptions with metrics
- Work experience section
- Education
- Clean modern formatting
- Proper section spacing
- No unnecessary design elements
- ATS friendly structure

Return only LaTeX code.

Then:

Copy LaTeX code
Paste into Overleaf
Download PDF
Done ✅

🧠 Bonus: Make AI Improve Your Resume

After generating resume:

Ask:

Analyze this resume like a senior recruiter hiring for a product-based company.
Give improvement suggestions.

Or:

Improve bullet points to be more impact-driven and metric-based.

AI becomes your career reviewer.

💡 Final Advice

AI won’t replace developers.
But developers using AI will replace developers who don’t.

Use AI to:

Think better
Write better
Present better
Position yourself better

Your skills + AI leverage = Career acceleration 🚀

If this helped you, drop a ❤️ and let me know —
Happy building!

Beyond If-Else: Pattern Matching as the Next Evolution in Control Flow

Karan — Tue, 18 Mar 2025 06:48:46 +0000

If you've been coding for any significant amount of time, you've likely found yourself deep in nested if-else statements or switch-case blocks that stretch far beyond what's comfortable to read or maintain. While these traditional control flow structures have served us well, modern languages are embracing a more powerful paradigm: pattern matching. This approach is transforming how we handle complex conditional logic, making code more readable, maintainable, and expressive.

The Problem with Traditional Control Flow

Let's face a harsh truth: traditional control flow structures don't scale well with complexity. Consider this JavaScript example:

function processPayment(payment) {
  if (payment.status === 'pending') {
    if (payment.method === 'credit') {
      if (payment.amount > 1000) {
        return handleLargeCredit(payment);
      } else {
        return handleSmallCredit(payment);
      }
    } else if (payment.method === 'bank_transfer') {
      return handleBankTransfer(payment);
    }
  } else if (payment.status === 'failed') {
    if (payment.attempts < 3) {
      return retryPayment(payment);
    } else {
      return notifyCustomerFailed(payment);
    }
  } else if (payment.status === 'completed') {
    return issueReceipt(payment);
  }
  return handleUnknownPayment(payment);
}

As the number of conditions grows, these structures become unwieldy. They're hard to read, difficult to modify, and prone to subtle bugs when edge cases are overlooked.

Enter Pattern Matching

Pattern matching allows developers to express complex conditional logic in a more declarative, structured way. It combines three powerful concepts:

Structural decomposition - Breaking down complex data structures
Condition testing - Evaluating predicates against the data
Binding - Capturing values for use in the handling code

Pattern Matching in JavaScript

JavaScript is evolving to include pattern matching capabilities through TC39 proposals. While not yet standard, the proposed syntax gives us a glimpse of how our code could look in the near future:

// Using the proposed pattern matching syntax
function processPayment(payment) {
  return match (payment) {
    when { status: 'pending', method: 'credit', amount } if amount > 1000 => 
      handleLargeCredit(payment),
    when { status: 'pending', method: 'credit' } => 
      handleSmallCredit(payment),
    when { status: 'pending', method: 'bank_transfer' } => 
      handleBankTransfer(payment),
    when { status: 'failed', attempts } if attempts < 3 => 
      retryPayment(payment),
    when { status: 'failed' } => 
      notifyCustomerFailed(payment),
    when { status: 'completed' } => 
      issueReceipt(payment),
    default => 
      handleUnknownPayment(payment)
  };
}

Even without native pattern matching, we can approximate some of its benefits using JavaScript's object destructuring and custom utilities:

// Using object destructuring and simple matchers
function processPayment(payment) {
  const { status, method, amount, attempts } = payment;

  // Pattern matching simulation
  if (status === 'pending' && method === 'credit' && amount > 1000) {
    return handleLargeCredit(payment);
  }

  if (status === 'pending' && method === 'credit') {
    return handleSmallCredit(payment);
  }

  if (status === 'pending' && method === 'bank_transfer') {
    return handleBankTransfer(payment);
  }

  if (status === 'failed' && attempts < 3) {
    return retryPayment(payment);
  }

  if (status === 'failed') {
    return notifyCustomerFailed(payment);
  }

  if (status === 'completed') {
    return issueReceipt(payment);
  }

  return handleUnknownPayment(payment);
}

Real-World Applications of Pattern Matching in JavaScript

Data Validation

function validateUserInput(input) {
  return match (input) {
    when { email, password } if isValidEmail(email) && password.length >= 8 =>
      { valid: true, user: { email, passwordHash: hashPassword(password) } },
    when { email } if !isValidEmail(email) =>
      { valid: false, error: 'Invalid email format' },
    when { password } if password.length < 8 =>
      { valid: false, error: 'Password too short' },
    default =>
      { valid: false, error: 'Missing required fields' }
  };
}

API Response Handling

function handleAPIResponse(response) {
  return match (response) {
    when { status: 200, data: { user: { name, role: "admin" } } } =>
      renderAdminDashboard(name),
    when { status: 200, data: { user: { name } } } =>
      renderUserDashboard(name),
    when { status: 401 } =>
      redirectToLogin(),
    when { status: 404 } =>
      showNotFound(),
    when { status } if status >= 500 =>
      showServerError(),
    default =>
      showUnexpectedError()
  };
}

State Management

function reducer(state, action) {
  return match (action) {
    when { type: 'INCREMENT', amount } =>
      { ...state, count: state.count + (amount || 1) },
    when { type: 'DECREMENT', amount } =>
      { ...state, count: state.count - (amount || 1) },
    when { type: 'RESET' } =>
      { ...state, count: 0 },
    when { type: 'SET_USER', user: { name, email } } =>
      { ...state, user: { name, email } },
    default =>
      state
  };
}

Bridging the Gap Today

While we wait for native pattern matching in JavaScript, several libraries offer similar functionality:

Using ts-pattern Library

import { match, P } from 'ts-pattern';

const result = match(payment)
  .with({ status: 'pending', method: 'credit', amount: P.when(n => n > 1000) }, 
    () => handleLargeCredit(payment))
  .with({ status: 'pending', method: 'credit' }, 
    () => handleSmallCredit(payment))
  .with({ status: 'pending', method: 'bank_transfer' }, 
    () => handleBankTransfer(payment))
  .with({ status: 'failed', attempts: P.when(n => n < 3) }, 
    () => retryPayment(payment))
  .with({ status: 'failed' }, 
    () => notifyCustomerFailed(payment))
  .with({ status: 'completed' }, 
    () => issueReceipt(payment))
  .otherwise(() => handleUnknownPayment(payment));

Using a Custom Matcher

const matcher = (value) => {
  const matches = [];

  return {
    when: (predicate, handler) => {
      matches.push({ predicate, handler });
      return matcher(value);
    },
    otherwise: (handler) => {
      for (const { predicate, handler: matchHandler } of matches) {
        if (predicate(value)) {
          return matchHandler(value);
        }
      }
      return handler(value);
    }
  };
};

// Usage
const result = matcher(payment)
  .when(p => p.status === 'pending' && p.method === 'credit' && p.amount > 1000, 
    p => handleLargeCredit(p))
  .when(p => p.status === 'pending' && p.method === 'credit', 
    p => handleSmallCredit(p))
  // ... other cases
  .otherwise(p => handleUnknownPayment(p));

Looking Ahead

As pattern matching becomes more integrated into JavaScript, we can expect to see several benefits:

Cleaner code with fewer nested conditions
Better error handling through exhaustive pattern checking
More declarative programming focusing on what to match rather than how to check
Enhanced readability making complex logic more approachable
Reduced bugs from overlooking edge cases

The future of control flow in JavaScript is moving toward more expressive, declarative patterns that handle complexity with grace. By understanding and adopting pattern matching concepts today, you'll be well-positioned as the language evolves.

Conclusion

Pattern matching represents a significant upgrade to how we manage complex conditional logic. While JavaScript's native implementation is still in progress, understanding these concepts and leveraging existing libraries can already improve your code quality. As the language continues to evolve, those who embrace these patterns early will find themselves writing more maintainable, expressive, and robust code.

Are you already using pattern matching-like approaches in your JavaScript projects? Share your techniques and experiences in the comments below!

The Rise of LLM-Powered Developer Tools: Evolution or Revolution?

Karan — Tue, 11 Mar 2025 12:03:50 +0000

If you've been writing code in the last year, you've undoubtedly encountered AI-powered coding assistants. From GitHub Copilot to Amazon CodeWhisperer, these tools have rapidly transformed from novelties to essential components of many developers' workflows. But are they fundamentally changing how we build software, or just speeding up existing processes?

The Current Landscape

The developer tools ecosystem has exploded with AI integrations:

IDE Extensions: Nearly every major IDE now offers LLM integration, with features ranging from code completion to natural language-based refactoring
CLI Tools: AI-powered command line tools can generate scripts, explain complex commands, and debug terminal errors
Code Review: Automated tools that not only identify bugs but suggest architectural improvements
Documentation: Systems that auto-generate documentation from code or create tutorials from natural language prompts

Beyond Just Autocomplete

What's interesting is how these tools are evolving beyond simple code completion:

Context-Aware Development: Modern LLM tools understand your entire codebase, not just the current file, allowing for more intelligent suggestions
Specialized Domain Knowledge: Tools trained on specific frameworks or domains provide expertise that would normally require years of experience
Natural Language Interface: The ability to express programming intent in plain English reduces the cognitive load of remembering syntax

The Productivity Paradox

Many developers report significant productivity gains:

30-50% faster development time for routine tasks
Reduced context switching when implementing standard patterns
Faster onboarding to new codebases or frameworks

But interestingly, the time saved isn't always spent shipping more features. Instead, developers report dedicating more effort to architecture design, testing, and improving code quality – potentially leading to more maintainable systems in the long term.

The Learning Curve Question

One persistent concern is how these tools affect learning. Does relying on AI assistance prevent developers from truly understanding the systems they build?
The evidence so far is mixed. Junior developers leveraging these tools report being able to contribute to projects more quickly, but some experienced mentors worry about fundamental gaps in understanding.
My hypothesis: we're heading toward a new kind of developer expertise – one less focused on memorizing APIs and more centered on system design, architectural understanding, and effectively collaborating with AI tools.

What's Coming Next?

The most exciting developments aren't just about better code completion, but about fundamentally different ways of building software:

Agent-based development: Autonomous systems that can implement entire features based on requirements
Continuous refactoring: Systems that constantly analyze and improve your codebase
Knowledge graph integration: Tools that connect your code with documentation, bug reports, and domain knowledge

Finding Balance

As with any technological shift, the key is finding balance. The most effective developers are learning to:

Use AI tools to handle repetitive tasks and boilerplate
Maintain critical thinking about architecture and design decisions
Verify and understand generated code before integrating it
Focus more energy on the uniquely human aspects of development: understanding user needs, team collaboration, and creative problem-solving

Your Experience?

Are you using AI-powered developer tools? How have they changed your workflow? I'd love to hear about your experiences in the comments!

This post represents my personal views and experiences with LLM-powered developer tools. I'm particularly interested in hearing perspectives from developers working in different domains and with different experience levels.

How to create service like Amazon S3 image upload for free using GitHub.

Karan — Thu, 06 Jun 2024 05:49:56 +0000

Hello folks! Welcome to this blog on developing the service like s3 image upload for freely using GitHub.

I've been working with technology for over two years now, And I get to know that we have been using s3 image upload service for some prize but if any beginner who's just creating his application in nest js or node js he/she can use this trick to upload the images to GitHub and by getting the URL of that image So that he/she can use it in the front-end So, this weekend, I decided to create this functionality, specifically NestJS.

Uploading images to the web can be a hassle, especially if you're working on a personal project or a small website without a budget for paid services like Amazon S3. Luckily, GitHub provides a neat solution to host your images for free!

GitHub is primarily a platform for hosting source code repositories, but it can also serve as a simple and free image hosting service. Here's how you can leverage GitHub for your image uploading needs:
1.Create a New Repository :
First, you'll need a GitHub repository to store your images. Go to github.com and create a new repository. You can name it something like "my-images" or "image-host". Make sure to initialize the repository with a README file. and keep it as public as your need!

I'll consider you have created basic setup for NestJS.

you can install required package:

npm install @octokit/rest

Simply you can follow my code for creating the github.helper.ts

import { Octokit } from '@octokit/rest';
import { encode } from 'base-64';
import { ConfigService } from '@nestjs/config';
import { Injectable, InternalServerErrorException } from '@nestjs/common';

@Injectable()
export class GithubHelper {
  private octokit: Octokit;
  private owner: string;
  private repo: string;
  private branch: string;

  constructor(private configService: ConfigService) {
    const accessToken = this.configService.get('GITHUB_TOKEN');
    this.owner = this.configService.get('GITHUB_OWNER');
    this.repo = this.configService.get('GITHUB_REPO');
    this.branch = this.configService.get('GITHUB_BRANCH');

    if (!accessToken || !this.owner || !this.repo) {
      throw new Error('Missing GitHub configuration in environment variables');
    }

    this.octokit = new Octokit({ auth: accessToken });
  }

  /**
   * Function to upload image
   */
  async uploadToRepository(folderPath: string, buffer: Buffer) {
    try {
      const fileData = buffer.toString('base64');

      await this.octokit.repos.createOrUpdateFileContents({
        owner: this.owner,
        repo: this.repo,
        path: folderPath,
        message: `Uploaded ${folderPath}`,
        content: fileData,
        branch: this.branch,
      });

      return {
        status: true,
        message: 'Image uploaded to GitHub repository successfully',
        fileResponse: {
          folderPath,
        },
      };
    } catch (error) {
      return {
        status: false,
        message: 'Error while uploading image to GitHub repository',
        fileResponse: error,
      };
    }
  }

  /**
   * Function to delete image from GitHub repository
   */
  async deleteFromRepository(filePath: string) {
    try {
      // Get the file SHA
      const response = await this.octokit.repos.getContent({
        owner: this.owner,
        repo: this.repo,
        path: filePath,
        ref: this.branch,
      });

      // Handle different response types
      const fileSha = Array.isArray(response.data)
        ? null
        : (response.data as { sha: string }).sha;

      if (!fileSha) {
        throw new Error(`File SHA not found for ${filePath}`);
      }

      // Delete the file
      await this.octokit.repos.deleteFile({
        owner: this.owner,
        repo: this.repo,
        path: filePath,
        message: `Deleted ${filePath}`,
        sha: fileSha,
        branch: this.branch,
      });

      return {
        status: true,
        message: 'File deleted from GitHub repository successfully.',
      };
    } catch (error) {
      console.error(`Error deleting file ${filePath}:`, error);
      throw new InternalServerErrorException(error);
    }
  }

  /**
   * Function to get the public URL for a file in the repository
   */
  async getFileUrl(filePath: string): Promise<string> {
    try {
      const response = await this.octokit.repos.getContent({
        owner: this.owner,
        repo: this.repo,
        path: filePath,
        ref: this.branch,
      });

      if (Array.isArray(response.data)) {
        throw new Error(`${filePath} is a directory, not a file`);
      }

      const fileUrl = response.data.download_url;
      return fileUrl;
    } catch (error) {
      console.error(`Error getting file URL for ${filePath}:`, error);
      throw new InternalServerErrorException(error);
    }
  }
}

Open the image.controller.ts file and update it with the following code:

import { Controller, Post, UploadedFile, UseInterceptors } from '@nestjs/common';
import { FileInterceptor } from '@nestjs/platform-express';
import { UploadService } from './upload.service';

@Controller('image')
export class ImageController {
  constructor(private readonly uploadService: UploadService) {}

  @Post('upload')
  @UseInterceptors(FileInterceptor('file'))
  async uploadImage(@UploadedFile() file: Express.Multer.File) {
    return this.uploadService.uploadToGitHub(file.buffer, file.originalname);
  }
}

Open the upload.service.ts file and add the following code:

import { GithubHelper } from '../../common/helper/github.helper';
import { GlobalHelper } from '../../common/helper/global.helper';

@Injectable()
export class uploadService{

async uploadToGitHub(file:any,payload:any){
        if (file) {
const extension = file.file.mimetype.split('/')[1];
          const fileName = `${payload.name}.${extension}`;
          const foodFolderPath = this.globalHelper.foodFolderPath(data.id);
          const totalPath = `${foodFolderPath}/${fileName}`;
          const uploadResult = await this.githubHelper.uploadToRepository(
            totalPath,
            file.file.buffer,
          );
          const url = await this.githubHelper.getFileUrl(totalPath);
       return {
        status:true,
        message:"image URL"
        data:{
          url,
         }
      }
    }
  }
}

get the required environment variables from the .ENV file.

I hope this tutorial helps you understand the concept behind implementing a GitHub service. There are a few alternative approaches as well, but I found this method easier to understand and implement. Please feel free to share your feedback and suggestions.

Thank you for reading 🙏

If you enjoyed this article or found it helpful, give it a thumbs-up 👍