DEV Community: Md Mim Akhtar

I Asked Job Seekers What They Hate About Resume Builders. The Results Changed My Roadmap.

Md Mim Akhtar — Sat, 06 Jun 2026 14:10:21 +0000

I'm currently building Here Is My CV, a Canva-like resume builder that helps people create resumes and online CVs.

Like many indie builders, I spend a lot of time deciding what to build next.

Should I add more templates?
More AI features?
More customization?

Recently, I realized I was making assumptions.

So I asked a simple question:

What frustrates you most about existing resume builders?

The options were:

ATS compatibility
Too many templates
Customization issues
Annoying paywalls

The results surprised me.

ATS Compatibility Won

I expected customization or pricing to come out on top.

Instead, ATS compatibility received the most votes.

At first, I thought people were asking for ATS optimization tools.

But after reading comments and talking to job seekers, I realized something else was happening.

Most people don't actually know whether their resume is ATS-friendly.

They don't know:

Which templates are safe to use
Whether formatting breaks during uploads
If ATS scanners can properly parse their content
Why some applications never receive responses

The issue wasn't ATS itself.

It was trust.

The Builder Mistake

As developers, we often think more features create more value.

Users don't always agree.

Many resume builders compete by adding:

More templates
More design options
More customization controls

But the feedback I received suggested people wanted something simpler.

They wanted confidence.

A clean template they could trust.

What I Shipped

Based on that feedback, I introduced a new template called ATS Classic.

Instead of focusing on visual complexity, the goal was:

Clean structure
Readable hierarchy
ATS-friendly formatting
Simple customization

Nothing revolutionary.

Just a template designed around the most common concern users shared.

Make your own ATS-friendly CV at https://hereismycv.com

My Biggest Takeaway

The most valuable product insights often come from asking simple questions.

I could have spent weeks debating feature priorities.

Instead, a small poll revealed a problem I had underestimated.

As builders, we often focus on what we think users want.

Sometimes it's worth pausing and asking them directly.

The answer might completely change what you build next.

What user feedback has completely changed the direction of a product you're building?

What is the most frustrating part of using resume builders?

Md Mim Akhtar — Wed, 20 May 2026 15:08:54 +0000

I’m currently in the process of building a new resume platform. As a developer, I’ve always found existing tools to be "clunky" or "too focused on templates over content".

I want to build something that actually solves the headaches we face, but I need your input to make sure I'm solving the right problems.

The Big Question

What do you dislike most about resume builders today?
Is it the UI, the export formats, the paywalls, or something else entirely?

Some things I'm curious about:

Parsing issues: Do you hate how builders mess up your formatting when importing a LinkedIn PDF?
Customization: Is it too hard to add custom sections (like Open Source or specific tech stacks)?
The "Paywall" Surprise: How do you feel about building a whole resume only to be asked for $20 to download it?

I’d love to hear your "horror stories" or the specific features you wish existed.

Let’s talk!

I’ll be hanging out in the comments to hear your thoughts and answer questions about what I'm building.

Quick Vote: What's the #1 offender?

❤️ - Hidden Paywalls
🦄 - Bad Export/PDF Formatting
🤯 - Limited Customization
🙌 - Poor ATS Optimization

or anything else? Maybe I can solve. Trust me 🙂‍↕️👀

Termim Is Becoming More Than Just “Better Terminal History”

Md Mim Akhtar — Fri, 15 May 2026 16:38:46 +0000

A few weeks ago, I introduced Termim as a way to stop shell history from bleeding across projects.

The idea was simple:

You run a Docker command in one repo…

then later press ↑ (arrow-up key) somewhere completely different and get unrelated history back.

That friction always felt unnecessary.

Since then, Termim has evolved quite a bit — both technically and conceptually.

From “Project-Aware” to Directory-Aware

One thing I realized while building this:

“Project-aware” wasn’t precise enough.

A lot of work happens inside projects:

nested backend folders
monorepos
temporary workspaces
isolated environments

So Termim now scopes history to your actual directory context, not project root.

That means:

cleaner recall
less irrelevant history
less searching through noise
What Changed Recently
Binary-First Installers

Here's What Changed Recently

Binary-First Installers

Installers were rewritten for:

Bash
Zsh
Fish
PowerShell

Instead of forcing local builds, Termim now downloads the correct Rust binary automatically.

Also added:

SHA256 checksum verification
idempotent installs
instant activation on Windows
In-Memory Secret Redaction

In-Memory Secret Redaction

This became important pretty quickly.

Termim now scrubs sensitive data before history is written:

API keys
JWTs
passwords
tokens

The filtering happens in-memory, so secrets never touch disk history.

Still Zero-Daemon

One thing I wanted to preserve from day one:

No background services.

Termim stays lightweight:

no daemon
low latency
Rust-native execution
minimal overhead

The shell should still feel fast.

Cross-Shell Parity

Behavior is now consistent across:

Bash
Zsh
Fish
PowerShell

The core interaction model is:

↑ → your directory history
↓ → predicted next commands

One Unexpected Thing

The most useful feedback I got wasn’t praise.

It was people saying:

“I still don’t understand what this actually does.”

And honestly, they were right.

That feedback forced me to explain the product more concretely, which ended up improving the direction of the project itself.

The real value of Termim isn’t “AI workflow optimization.”

It’s much simpler:

keeping terminal history relevant to where you actually are.

Architecture & Internals

I also added a detailed ARCHITECTURE.md covering:

state management
locking
prediction flow
shell integration
execution model

For anyone interested in the internals.

GitHub: https://github.com/akhtarx/termim

Still early. Still refining.
But the direction feels much clearer now.

Ever Caught Yourself Pressing (arrow-up key) Over and Over?

Md Mim Akhtar — Fri, 10 Apr 2026 07:09:38 +0000

Looking for that one command you just ran…

You press ↑
Not the one
Press ↑ again
Still not it

A few more times…
Now you’re just scrolling through your past like it’s a timeline.

It Feels Normal. But It’s Not Efficient.

If you use the terminal a lot, this probably happens daily:

Scrolling through command history
Running history | grep something
Copy-pasting commands from old notes

It works.

But it slows you down more than you realize.

The Real Issue Isn’t Speed

The terminal is fast.

The problem is recall.

Everything depends on:

What you remember
How fast you can find it again

And most of the time… you don’t remember exactly.

My Setup Wasn’t Bad Either

I was already using:

zoxide for directory jumping
rg for searching
Aliases for common commands

Still, I kept running into the same friction.

Tools were helping — but not solving the core issue.

So I Built Termim

Not to replace the terminal.
Not to overcomplicate things.

Just to fix one thing:

Finding and reusing commands quickly

What Termim Tries to Do

Make history actually useful
Reduce repeated typing
Help you get back to commands instantly

No noise. No unnecessary layers.

Why This Matters

Those small delays?

They stack up.

A few seconds here and there, multiple times a day —
it adds up more than you think.

Curious About You

If you spend a lot of time in the terminal:

How do you find old commands?
Do you rely on ↑ or something better?
What’s your setup like?

GitHub: https://github.com/akhtarx/termim

Would love your thoughts.

I Was Tired of My Terminal Being Dumb — So I Built Termim

Md Mim Akhtar — Wed, 08 Apr 2026 11:41:24 +0000

Ever tried to find a command in your terminal history by pressing ↑ the up arrow key repeatedly?

If you use the terminal a lot, you’ve probably faced this:

You know you’ve run a command before…
But now you’re stuck doing:

Ctrl + R → type → scroll → scroll → wrong command → repeat

And somehow, it still pulls results from a completely different project.

That’s when it hit me:

Shell history isn’t broken because it’s slow.
It’s broken because it has zero context.

Matters Beyond My Own Workflow

As someone who regularly switches between open-source projects, experiments, client work, and personal repositories, I kept running into the same problem: terminal history had no understanding of context.

This isn't unique to me. Many developers across APAC work across multiple repositories every day... whether building startups, contributing to open source, freelancing, or learning new technologies.

A single global command history creates unnecessary friction:

Commands from unrelated projects surface during searches
Useful workflows become difficult to rediscover
Developers spend time recalling commands instead of solving problems

The more projects you manage, the worse the experience becomes.

Termim started as an attempt to solve this everyday productivity problem.

So I built something to fix that.

Meet Termim

Termim = your terminal remembers per project.

Instead of one global history mess, Termim gives you:

Project-specific history
Behavior-based suggestions
Fast navigation without friction

No noise. Just relevant commands.

The Real Problem

Your terminal history today:

mixes all projects together
has no idea where you are
treats everything as equal

So when you search, you get:

commands from last week
commands from another repo
commands that don’t even apply anymore

It’s not helpful—it’s overwhelming.

What Termim Changes

1. Project-Aware History

When you’re inside a project:

you only see commands from that project
no cross-project pollution
no accidental mistakes

Your ↑ (arrow up) key finally makes sense again.

2. It Learns How You Work

Termim doesn’t just store commands—it tracks patterns.

Example:
git add . → git commit → git push

Over time, it learns these flows using weighted transitions.

So instead of searching, you just… move forward.

3. Navigation That Feels Natural

↑ → project history → global history
↓ → back into project → predictions

No new mental model.

Just better behavior.

4. Built for Speed

No DB. No daemon. No bloat.

~15ms latency
zero dependency core
works across Bash, Zsh, Fish, PowerShell

It feels like part of your shell, not an add-on.

Adding Generative AI to the Terminal Experience

While Termim's history engine is intentionally deterministic and lightweight, I also explored how Generative AI can improve command discovery and workflow understanding.

Using Google's Gemini models, command histories and workflow patterns can be analyzed semantically rather than treated as plain text.

This opens up possibilities such as:

Explaining previously executed commands in natural language
Understanding the intent behind command sequences
Summarizing repetitive workflows
Assisting developers who are unfamiliar with a project's command patterns
Predicting likely next actions based on historical context

Rather than replacing the terminal, the goal is to make it easier for developers to understand and reuse their existing workflows.

Why I Didn’t Just Use Existing Tools

I tried tools like Atuin, McFly, etc.

They’re good—but:

they still feel global
context is “soft”, not enforced
some rely on background services

I wanted something stricter and simpler:

When I’m in a project, my terminal should behave like it knows it.

Small Details That Matter

A few things I cared a lot about:

Hard context isolation (no leaking commands)
Success-only learning (ignore failed commands)
Privacy-first (everything local, secrets redacted)
Deterministic behavior (no randomness in navigation)

Built with Google AI Tools

During the development of Termim, I used Google's Gemini models as a development assistant for brainstorming architecture decisions, refining algorithms, evaluating edge cases, and accelerating implementation.

Gemini helped me iterate on ideas more quickly, explore alternative approaches, and improve documentation throughout the project.

While Termim's core engine is implemented in Rust and operates locally without AI dependencies, Generative AI played an important role in the development process and experimentation around future workflow intelligence features.

What It’s Not

Termim is NOT:

an AI copilot
a cloud product
a heavy productivity suite

It’s intentionally minimal.

It solves one problem well:

making terminal history actually useful.

Who This Is For

If you:

jump between multiple repos daily
live inside your terminal
rely on command recall a lot

You’ll feel the difference immediately.

Final Thought

We’ve accepted bad terminal history for years.

Termim is just a small attempt to fix that.

Not by adding more features... but by adding context.

Termim on GitHub: Termim
Built using Rust
Experimenting with Google Gemini for workflow understanding and command intelligence

If you want to try it or give feedback, I’d genuinely appreciate it 🙌

Shipped Eid Mubarak Effect 🌙

Md Mim Akhtar — Fri, 27 Feb 2026 17:26:06 +0000

Just pushed a new seasonal experience live on Seazonify.

Opening golden gates.
Floating lanterns.
Soft glow. Dark night backdrop.

Purely made using HTML, CSS, and JS. Lag-free, responsive, optimized.

Try it on your website at https://app.seazonify.com/workspace

Designed to feel elegant and celebratory — not noisy.
Everything is responsive and performance-first.
Seasonal shouldn’t mean heavy.

Still refining motion smoothness and interaction control next.
Building Seazonify in public.

seazonify #effects #webdev #frontend #visualeffects #visualeffectforweb #seasonaleffects

Shipped 6+ visual effects on Seazonify ✨

Md Mim Akhtar — Mon, 26 Jan 2026 11:06:22 +0000

Shipped 6+ visual effects on Seazonify ✨

These effects are lightweight, non-intrusive, and performance-first.

Explore them at https://app.seazonify.com/workspace

I’ve been building Seazonify quietly for a while.

Starting today, I’ll be sharing Seazonify’s progress daily in public: from 26th January, 2026, until launch and beyond.

No hype.

No filters.

Just what we’re building, what works, and what doesn’t.

Let’s see where this goes.

Day 1 of Building #Seazonify 🍁

opensource #buildinpublic #frontend #web

I’m building Seazonify — a free library of seasonal audio-visual effects for websites

Md Mim Akhtar — Tue, 20 Jan 2026 08:02:40 +0000

I’ve been building a platform called Seazonify that lets you add ambient visuals and background sounds to websites — like snowfall in winter, rain on rainy days, or festive effects during holidays.

The goal is to bring websites to life without needing users to code complex animations.

🛠️ What it does:

One-line script to embed visual/audio ambience
Effects are auto-loaded based on season, time, or weather
Fully open-source visual + audio effects library
You can test the effects live on your own site

Examples:

❄️ Snowfall during winter
🌧️ Rain when it's cloudy
🌸 Petals in spring
🎆 Fireworks on New Year’s Eve

⚙️ I’m building this solo and slowly expanding the effects library.

💬 I’d love to know:

Would you ever use something like this on a site?
Do you think seasonal ambience helps or distracts?
What kind of effects would you love to see?

Open to feedback, criticism, or questions! 🙏

Thanks for reading.