DEV Community: keshav jha

I Rebuilt My Developer Portfolio Around the Work, Not the Tech Stack

keshav jha — Tue, 06 Oct 2026 07:51:53 +0000

I recently gave my developer portfolio a major update. I’m still iterating on it and improving things as I go, but I thought I’d share it now and get some feedback from others.

👉 Portfolio: https://keshavkjha.com

After 7+ years of building software, I realized my old way of presenting myself had a problem.

Like many developer portfolios, it was easy to focus on things like:

React. Go. Python. Node.js. PostgreSQL. Kubernetes. AWS. Docker.

Those things matter.

But they don't really explain what I do.

A technology list doesn't show whether someone can take an unclear product idea, make technical decisions, build the system, ship it, debug the uncomfortable parts, deploy it, and continue owning it when real users arrive.

That's what I wanted the new portfolio to communicate.

From "here are my skills" to "here is what I built"

Most of my career has been product-oriented.

I've worked on products ranging from fintech and logistics to SaaS, internal business systems, ecommerce, AI workflows, APIs, infrastructure, and customer-facing applications.

So instead of making the portfolio primarily about technologies, I reorganized it around actual work and engineering ownership.

The new version currently includes 12 case studies.

Some examples:

Visionboarder

A social vision-board product where my work extends across the customer application, admin tooling, backend systems, AI features and workflows using open-source AI models, media processing, databases, infrastructure, and deployment.

That includes models and systems around LTX-2.3, LTX-2.5, FLUX.1, FLUX.2, Z-Image Turbo, content moderation, NSFW detection, image/video generation, and related workflows.

The wider stack includes things like Next.js, React, TypeScript, Go, Python, RabbitMQ, Redis, PostgreSQL, serverless AI model deployment on RunPod, Docker, Kubernetes, and CI/CD.

But the interesting part isn't really the stack.

It is owning the path from a product requirement all the way to a production system.

Kotak Gateway / Kotak Neo

I worked on SDK and API-driven experiences for integrating investment and trading journeys into other products.

This kind of work taught me a lot about building software where your own application isn't the only thing that matters.

The integration experience, API contracts, reliability, communication between teams, backward compatibility, and developer experience become part of the product too.

SITA Operations Platform

An internal product that helped move operational work away from spreadsheet-based coordination and into a proper application.

Not every valuable engineering problem needs a new AI model or a complicated distributed architecture.

Sometimes the most valuable system is the one that removes an inefficient workflow people have tolerated for years.

EasyGlobalShip

A shipping platform for Indian ecommerce sellers covering areas such as rates, shipment booking, labels, customs documentation, and tracking.

This was one of the projects that reinforced something I still strongly believe:

Understanding the business problem often matters more than choosing an impressive technology.

And there are several other projects covering contract management, hospitality, workspace booking, internal audit systems, ecommerce, and different stages of my engineering journey.

My stack became wider because the problems became wider

I started my career much closer to traditional web development.

PHP. WordPress. Laravel. JavaScript.

Then the problems changed.

Frontend applications became more complex.

I moved deeper into React and TypeScript.

Backend requirements pushed me further into Node.js and Go.

AI products brought Python and model-serving workflows into the picture.

Running those systems meant working more seriously with PostgreSQL, Redis, queues like RabbitMQ and Kafka, Docker, Kubernetes, OpenTofu, CI/CD, observability, and infrastructure.

At some point I stopped thinking of myself primarily as a developer for a particular framework.

The question became:

What does this product need in order to work well?

Sometimes that's a React interface.

Sometimes it's a Go service.

Sometimes it's a Python worker running an AI model.

Sometimes it's redesigning the database.

Sometimes it's fixing the deployment system.

And sometimes the correct answer is removing complexity rather than adding another service.

One thing AI has changed for me

The last couple of years have obviously changed software development.

For the past few months, I've been using AI much more heavily throughout my development workflow. Before that, I mostly used it for smaller fixes, research, and occasional assistance.

But I don't think the interesting part is simply generating more code.

The bigger advantage is shortening the distance between:

idea → exploration → documentation / product standards → specs → implementation → validation → iteration

AI can help investigate a codebase, generate repetitive implementation work, compare approaches, write tests, search for edge cases, review assumptions, and even challenge decisions.

That gives me more room to think about architecture, product behaviour, failure modes, trade-offs, and the decisions that are difficult to automate.

I still think engineering judgment becomes more important in an AI-assisted development environment, not less.

Generating 5,000 lines of code is becoming cheap.

Knowing whether those 5,000 lines should exist is still valuable.

What I wanted this portfolio to show

I didn't want the new site to say:

Here are 30 technologies I know. Please hire me.

I wanted someone looking through it to understand how I actually work.

Can I enter an existing product and understand it?

Can I take ownership of something ambiguous?

Can I work across frontend and backend?

Can I build an API rather than only consume one?

Can I deal with infrastructure and deployment?

Can I integrate AI without turning the whole architecture into an AI demo?

Can I work directly with founders, product owners, and engineering teams?

Can I take something from an idea to production?

Those are much more useful questions than whether I have used Framework X for exactly four or six years.

I'm also open to the right next project

I'm currently open to remote opportunities and engineering engagements.

That can mean a focused contract, a longer-term product engagement, or the right senior full-stack / product engineering role.

I'm particularly interested in work involving:

building or scaling products
backend and distributed systems
Go, Python, TypeScript, and React
AI-enabled products and workflows
APIs and integrations
ecommerce and commerce infrastructure
developer tooling and internal systems
infrastructure, CI/CD, and production engineering
products where I can own a meaningful outcome rather than just close isolated tickets

I'm based in India and comfortable working with distributed teams across time zones.

But I'm not trying to optimize purely for finding any available work.

I'm much more interested in finding products where engineering has a meaningful impact on what gets built and where ownership is valued.

If you're building something interesting, need another experienced engineer on an existing system, or simply want to compare notes on product engineering, feel free to reach out.

👉 https://keshavkjha.com

[Boost]

keshav jha — Tue, 31 Dec 2024 13:52:01 +0000

Seeking Opportunities as a Software Engineer

keshav jha — Tue, 17 Sep 2024 12:50:56 +0000

Hello Dev.to community,

I hope this post finds you all in great spirits!

I'm excited to share that I’m currently on the lookout for new opportunities as a Software Engineer. Over the past 3+ years, I’ve had the chance to work on a variety of intriguing projects, and I’d love to take this opportunity to reflect on my journey and the skills I bring to the table.

A Journey Through Innovation

My career has taken me through a range of experiences:

Advanced Trading Solutions: I contributed to the development of an advanced trading solution for Kotak Securities, enhancing their FinTech offerings.
Travel Management Platform: At Sita.in, I helped build a modular UI that streamlined their travel management platform, driving operational efficiency.
Social Media Application: Most recently, I led the end-to-end development of a social media platform focused on vision boards, akin to Pinterest. This project allowed me to leverage my full stack skills, including integrating machine learning for NSFW moderation and text-to-image AI generation.

Skills and Expertise

Here’s a snapshot of the technologies and methodologies I’ve been working with:

HTML5, CSS3, Talwindcss, SCSS, JavaScript, Typescript, Node.Js, Prisma.JS, React, Zustand, Redux, Redux Saga, Next.JS, Svelte, Sveltekit, GIT, AWS, Azure, Go(Golang), SQL, RabbitMQ, REST APIs.

My experience spans creating scalable solutions, delving into cloud technologies, and building robust event-driven architectures. I’m passionate about crafting efficient, scalable solutions and continuously learning to stay at the cutting edge of technology.

What I’m Looking For

I am eager to connect with teams and projects that are driven by innovation and creativity. Whether you're looking for a full-time engineer or a contract-based role, I am open to exploring various opportunities where I can contribute my skills and grow further.

Let’s Connect

If you’re interested in discussing potential opportunities or just want to chat about technology and development, feel free to reach out to me directly here on Dev.to or drop me an email at keshavkumarjha890@gmail.com or connect with me on Linkedin

Resume: Linkedin link
Looking forward to connecting with you and exploring new horizons!

Best regards,

Keshav Jha

leetcode: Median of Two Sorted Arrays Problem in C++

keshav jha — Thu, 11 Apr 2024 14:08:03 +0000

Introduction:

Finding the median of two sorted arrays efficiently. In this blog post, we'll explore how to solve this problem in C++, achieving a runtime complexity of O(log(m+n)).

Problem Statement:

Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.

The overall run time complexity should be O(log (m+n)).

Example 1:

Input: nums1 = [1,3], nums2 = [2]
Output: 2.00000
Explanation: merged array = [1,2,3] and median is 2.

Example 2:
Input: nums1 = [1,2], nums2 = [3,4]
Output: 2.50000
Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.

Constraints:

nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 106

Approach:

To solve this problem efficiently, we'll utilise the binary search algorithm. The key insight is to partition the arrays nums1 and nums2 into two parts such that the elements on the left side are smaller than or equal to the elements on the right side. This partition should be such that the length of the left partition is equal to or one element larger than the length of the right partition.

Algorithm:

Ensure nums1 is not larger than nums2. If it is, swap them.
Initialize low and high as 0 and the length of nums1, respectively.
Perform a binary search on nums1 to find the correct partition partN1.
Calculate the corresponding partition partN2 in nums2.
Determine the maximum elements (mxLN1 and mxLN2) on the left side and the minimum elements (minRN1 and minRN2) on the right side.
Check if the partitioning is correct, ensuring that mxLN1 <= minRN2 and mxLN2 <= minRN1.
If the partitioning is correct, calculate the median based on the lengths of nums1 and nums2.
Adjust low and high based on the comparison of mxLN1 and minRN2.
Repeat the binary search until the correct partition is found.

Code C++

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        unsigned int n = nums1.size(), m = nums2.size();

        if (n == 0 && m == 0)
            return double(0);

        if (n == 0) {
            if (m % 2 == 0) {
                return (nums2[m / 2 - 1] + nums2[m / 2]) / 2.0;
            } else {
                return nums2[m / 2];
            }
        }

        if (m == 0) {
            if (n % 2 == 0) {
                return (nums1[n / 2 - 1] + nums1[n / 2]) / 2.0;
            } else {
                return nums1[n / 2];
            }
        }

        if (n > m) {
            return findMedianSortedArrays(nums2, nums1);
        }

        int low = 0, high = n;

        while (low <= high) {
            int partN1 = (low + high) / 2;
            int partN2 = (n + m + 1) / 2 - partN1;

            int mxLN1 = (partN1 == 0) ? INT_MIN : nums1[partN1 - 1];
            int minRN1 = (partN1 == n) ? INT_MAX : nums1[partN1];

            int mxLN2 = (partN2 == 0) ? INT_MIN : nums2[partN2 - 1];
            int minRN2 = (partN2 == m) ? INT_MAX : nums2[partN2];

            if (mxLN1 <= minRN2 && mxLN2 <= minRN1) {
                if ((n + m) % 2 == 0) {
                    return (max(mxLN1, mxLN2) + min(minRN1, minRN2)) / 2.0;
                } else {
                    return max(mxLN1, mxLN2);
                }
            } else if (mxLN1 > minRN2) {
                high = partN1 - 1;
            } else {
                low = partN1 + 1;
            }
        }

        return 0.0;
    }
};

Code Explanation:

We handle edge cases where one of the arrays is empty or both arrays are empty.
We ensure that the length of nums1 is smaller or equal to the length of nums2.
We perform a binary search to find the correct partition in nums1.
We calculate the corresponding partition in nums2.
We check if the partitioning is correct and calculate the median accordingly.
We adjust the search space based on the comparison of elements.

Complexity Analysis:

Time Complexity: O(log(min(m, n))) - The binary search is performed on the smaller array.
Space Complexity: O(1) - Only a constant amount of extra space is used.

Conclusion:

We discussed how to efficiently solve the median of two sorted arrays problem in C++ using a binary search approach. By partitioning the arrays intelligently, we were able to achieve a runtime complexity of O(log(m+n)).

Change Themes in Next.js 14 without Wrapping Children in Context .

keshav jha — Wed, 10 Apr 2024 11:51:15 +0000

Introduction

In Web applications, theming plays a crucial role in providing a personalised and visually appealing user experience. One common approach is to use a ThemeProvider Context to manage themes across the application. There is no problem with application's which is completely client side. This blog is specific to developer who is looking for a solution where there application is combination of client and server components and theming depends on color-schema or className.

With the release of Next.js 14+, wrapping children in a Context will make children a client component. In this blog post, we'll explore how to implement a ThemeProvider which will help us to avoid wrapping complete application into a Context provider.

Implementing Theme Provider in Next.js 14+

To implement the Theme Provider without wrapping children in Context, we'll follow these steps:

Install Dependencies: Ensure you have the necessary dependencies installed, including next-themes for theme management and cookies-next for cookies management.
Create Theme Provider Component: Develop a custom ThemeProvider component that handles theme switching and cookie management.
Integrate Theme Provider: Integrate the ThemeProvider component into your application layout to make sure client theming is synced with server on hydration.
Use Theme Switcher : Integrate the ThemeProvider component into your application to switch theme.

Let's dive deeper into each step.

Step 1: Install Dependencies

First, make sure you have next-themes installed in your Next.js project. If not, you can install it using npm or yarn:

npm install next-themes cookies-next
# or
yarn add next-themes cookies-next

Step 2: Create Theme Provider Component

In your project, create a custom ThemeProvider component that leverages next-themes for theme management. This component will handle theme switching and cookie management for server-side rendering.

// components/context/theme.tsx
import { setCookie } from "cookies-next";
import { ThemeProvider, useTheme } from "next-themes";
import type { ThemeProviderProps } from "next-themes/dist/types";
import { useEffect } from "react";

// Application theme provider
function AppThemeProvider({ children, ...props }: ThemeProviderProps) {
  return (
    <ThemeProvider enableColorScheme {...props}>
      <AppThemeProviderHelper />
      {children}
    </ThemeProvider>
  );
}

// Helper component to set theme in cookie
function AppThemeProviderHelper() {
  const { theme } = useTheme();

  useEffect(() => {
    setCookie("__theme__", theme, {
      expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
      path: "/",
    });
  }, [theme]);

  return null;
}

export default AppThemeProvider;

Step 3: Integrate Theme Provider

Now, integrate the ThemeProvider component into your application layout in your app/layout.tsx file or any child layout as per requirement:

import { MonaSans_Font } from "@/assets/fonts/MonaSans";
import dynamic from "next/dynamic";

const AppThemeProvider = dynamic(() => import("@/components/context/theme"), {
  ssr: false,
});

export default async function AppLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  const theme = cookies().get("__theme__")?.value || "system";

  return (
    <html
      className={theme}
      lang="en"
      style={theme !== "system" ? { colorScheme: theme } : {}}
    >
      <body className={`${MonaSans_Font.className} flex flex-col h-full w-full overflow-hidden`}>
        {children}

        <AppThemeProvider 
           attribute="class" 
           defaultTheme={theme} 
           enableSystem 
        />
      </body>
    </html>
  );
}

Step 4: Integrate Theme Provider in Theme Switching

A Tab's based switcher can be created as below to switch theme Using AppThemeProvider.

"use client";

import AppThemeProvider from "@/components/context/theme";
import { Tabs, TabsList, TabsTrigger } from "ui/components/tabs";
import { useTheme } from "next-themes";

function Tab() {
  const { setTheme, theme } = useTheme();
  return (
    <Tabs className="w-full" onValueChange={setTheme} value={theme}>
      <TabsList className="grid w-full grid-cols-3">
        <TabsTrigger value="light">Light</TabsTrigger>
        <TabsTrigger value="dark">Dark</TabsTrigger>
        <TabsTrigger value="system">System</TabsTrigger>
      </TabsList>
    </Tabs>
  );
}

function ThemeTabs() {
  return (
    <AppThemeProvider attribute="class" defaultTheme="system" enableSystem>
      <Tab />
    </AppThemeProvider>
  );
}

export default ThemeTabs;

Conclusion

Implementing a Theme Provider in Next.js 14+ without wrapping children in Context offers a cleaner and more efficient way to manage themes in your application without making complete application a client component.

Leetcode: Reveal Cards In Increasing Order

keshav jha — Wed, 10 Apr 2024 07:24:52 +0000

Revealing a Deck of Cards in Increasing Order

Description

You are given an integer array deck. There is a deck of cards where every card has a unique integer. The integer on the ith card is deck[i].

You can order the deck in any order you want. Initially, all the cards start face down (unrevealed) in one deck.

You will do the following steps repeatedly until all cards are revealed:

Take the top card of the deck, reveal it, and take it out of the deck.
If there are still cards in the deck then put the next top card of the deck at the bottom of the deck.
If there are still unrevealed cards, go back to step 1. Otherwise, stop.
Return an ordering of the deck that would reveal the cards in increasing order.

Note that the first entry in the answer is considered to be the top of the deck.

Example 1:

Input: deck = [17,13,11,2,3,5,7]
Output: [2,13,3,11,5,17,7]
Explanation:
We get the deck in the order 17,13,11,2,3,5,7, and reorder it.
After reordering, the deck starts as [2,13,3,11,5,17,7], where 2 is the top of the deck.
We reveal 2, and move 13 to the bottom. The deck is now [3,11,5,17,7,13].
We reveal 3, and move 11 to the bottom. The deck is now [5,17,7,13,11].
We reveal 5, and move 17 to the bottom. The deck is now [7,13,11,17].
We reveal 7, and move 13 to the bottom. The deck is now [11,17,13].
We reveal 11, and move 17 to the bottom. The deck is now [13,17].
We reveal 13, and move 17 to the bottom. The deck is now [17].
We reveal 17.
Since all the cards revealed are in increasing order, the answer is correct.
Example 2:

Input: deck = [1,1000]
Output: [1,1000]

Constraints:

1 <= deck.length <= 1000
1 <= deck[i] <= 106
All the values of deck are unique.

Revealing a deck of cards in increasing order can be a fascinating problem to solve efficiently. In this article, we'll explore an approach that utilises a specific pattern to reveal the cards in ascending order, considering a given initial ordering.

Approach

By observing the behaviour from the bottom to the top of the sorted deck, I notice a repetitive process: pop the last element, place it at the beginning, and insert the next element from the original deck also at the beginning. This pattern ensures that the revealed deck ends up in increasing order.

Complexity Analysis

Time Complexity: Sorting the deck initially dominates the time complexity. We use the sort() function, which typically employs an efficient sorting algorithm such as QuickSort. Therefore, the time complexity of sorting is O(n log n), where n is the size of the deck. However, if the deck is already sorted, the time complexity reduces to O(n) as there would be no need for sorting.
Space Complexity: The space complexity is O(n) since we use an additional vector to store the revealed deck.

Implementation

Here's a C++ implementation of the above approach:

class Solution {
public:
    vector<int> deckRevealedIncreasing(vector<int>& deck) {
        // Sort the deck in descending order
        sort(deck.begin(), deck.end(), greater<int>());

        // Initialize a vector to store the revealed deck
        std::vector<int> revealedDeck;

        // Iterate through the sorted deck to reveal cards in increasing order
        for (const int& card : deck) {
            if (revealedDeck.empty()) {
                revealedDeck.insert(revealedDeck.begin(), card);
            } else {
                // Pop the last card and place it at the beginning
                int lastCard = revealedDeck.back();
                revealedDeck.pop_back();
                revealedDeck.insert(revealedDeck.begin(), lastCard);
                // Insert the next card from the original deck at the beginning
                revealedDeck.insert(revealedDeck.begin(), card);
            }
        }

        return revealedDeck;
    }
};

By following this approach, we can efficiently reveal a deck of cards in increasing order based on a given initial ordering.

Stats

Can i get a review or tips for my portfolio website?

keshav jha — Mon, 04 May 2020 08:46:49 +0000

Hello everyone!

I'm graduating this year and got hired by a company through campus placement. But due to quarantine(coronavirus) joining is to be delayed.

So I decided to work as a freelancer developer and joined Upwork. But so far got one project only. Then due to lack of works, I decided to build a small personal website for myself. So i can get more projects but no luck.

LINK: https://keshakjha.com

It's built using HTML,CSS(SCSS),JQuery(masonry) and hosted on netlify.

I want you guys to review my portfolio and tell me, where do i lack or can improve. Also any suggestion for self improvement to get better opportunities are welcome.

Thanks in advance.