Hashnode Multi-Site Bugs, Blog Architecture Rethink, and Cracking LeetCode #15 3Sum

Started the day with a job application, ended up down a rabbit hole

It started simple enough — I was going to apply for a senior software engineer position and needed to update my portfolio. But the moment I opened my blog site, I noticed something that had been bugging me for a while: my journals and my proper articles were sitting side by side on the same Hashnode blog, and they just didn't belong together.

My detailed, meaningful articles deserve a clean space. And my journals, well, anyone who wants to follow the day-to-day grind can read those separately. Mixing them together makes neither look good. So I decided to split them.

Hashnode: multiple blogs, multiple headaches

The plan was straightforward. Create two separate blogs on Hashnode and map my subdomains:

• blog.ramankarki.dev → the real, polished articles

• journal.ramankarki.dev → the daily dev diary

The blog site came up fine. The journal site, though? Nothing. It just wouldn't work properly. My best guess is there's a bug in Hashnode when you try to run multiple blogs under a single account. I couldn't pin it down exactly, but something is clearly broken there.

On top of that, I ran into 3 more annoying issues on the platform:

Bug #1 — Publication switch not working. There's supposed to be a way to switch between multiple blog publication, but clicking it did nothing for me. Posts just stayed as-is regardless of what I selected.

Bug #2 — Date/time update broken. I tried to correct the publish date on a few journal entries. The date picker lets you set the date and time separately — I'd pick, say, February 18 at 9 PM — but after hitting update, it would save as February 18 at 12 AM. I confirmed this by right-clicking and checking the actual post data.

Bug #3 — Inconsistent dates across views. There's also a mismatch between how the date appears on the homepage vs inside the article itself. One article showed February 18, 2026 on the listing, but February 17, 2026 when you actually opened it. I don't know what's going on there.

---

Looked at alternatives — Dev.to and Notion

At this point I took a detour and looked at other platforms. Dev.to was the first one I checked, but it doesn't support custom domains and you're fully locked into their platform. That was a no-go — I want to own my content and my URLs.

Notion was next. You can technically turn Notion pages into a public-facing site, but the customization options feel too limited. I need full control over the UI and the ability to serve the journal and articles from clearly separate paths so readers don't get lost jumping between them.

Neither was the right fit.

---

Rethinking the whole approach: build a unified portfolio

Here's where my thinking shifted. I originally wanted a super minimal portfolio — just a single page with my name, my job title, and links out to my blog and whatever else. Quick, clean, done.

But if I'm going to have two separate content sections (detailed blog posts and journals), making visitors bounce between two different sites creates a bad experience. Every time someone clicks a link, they're context-switching to a completely different domain.

The cleaner solution is to build a single platform that has everything in one place: a projects section, a blog section, and a journal section. All under one roof.

I've been resisting building a custom portfolio because it felt like time that wasn't directly productive. But now there's an actual reason for it beyond aesthetics. The plan is to get through a web development with AI course first so I can leverage that to build the site faster, then actually build it properly.

---

LeetCode #15 — Three Sum

Later in the day I worked through LeetCode problem 15, Three Sum. The problem asks you to find all unique triplets in an array where the three numbers add up to zero, with no duplicate triplets in the result.

I'd solved a similar problem before — find a pair of numbers in a sorted array that sum to a target, using a two-pointer approach. Left pointer starts at index 0, right pointer starts at the last index, and you walk them inward based on whether the current sum is too high or too low.

Three Sum extends this by one dimension. The input isn't sorted, so first step is to sort it yourself. Then you loop over each element, fix it as the first number of the triplet, and run the two-pointer search on the rest of the array to find the other two.

The deduplication part is where things got interesting. To avoid returning the same triplet twice, I tracked already-found triplets using a map. I'd represent each triplet as a sorted array joined into a string, then check if that string already existed in the map before adding it.

Here's the rough flow:

sort the input array

for each number (fixed as first of triplet):
    set left = next index, right = last index
    
    while left < right:
        sum = fixed + nums[left] + nums[right]
        
        if sum == 0:
            build triplet string (sorted, joined)
            if not in map:
                add to output, store in map
            move both pointers inward
        
        elif sum > 0:
            right--
        
        else:
            left++

I hit an infinite loop bug early on because I was checking for duplicates before checking if the sum equalled zero. The loop would find a sum of zero, see the triplet already in the map, and then just... break without moving the pointers. So it'd re-check the same indices over and over.

The fix was simple once I saw it: check if sum equals zero first, then check the map. If it's a duplicate, still increment and decrement the pointers before continuing. That way the loop always makes progress.

function threeSum(nums: number[]): number[][] {
    nums.sort((a,b) => a - b)
    const map = new Map()
    const output = []

    for (let i = 0; i < nums.length; i++) {
        let left = i + 1;
        let right = nums.length - 1
        const num = nums[i]
        while (left < right) {
            const sum = num + nums[left] + nums[right]
            if (sum === 0) {
                const triplet = [num, nums[left], nums[right]]
                const tripletKey = triplet.sort((a, b) => a - b).join('')
                if (map.has(tripletKey)) {
                    left++
                    right--
                    continue
                }
                output.push(triplet)
                map.set(tripletKey, true)
            }
            else if (sum > 0) right--
            else left++
        }
    }

    return output
};

---

Day summary

A day that started as a quick portfolio update turned into a platform architecture decision and a bug-hunting session. Hashnode's multi-blog support has some real rough edges. Might end up building my own thing sooner than expected. And Three Sum is solved — that infinite loop was a good reminder that control flow bugs hide in the order you check conditions, not just the conditions themselves.