Forem: Manthan Bhatt

Architecture lessons from building software for real business workflows

Manthan Bhatt — Tue, 14 Apr 2026 09:42:20 +0000

One thing that stands out when working on real SaaS and operational products is that software complexity rarely comes from code alone.

It usually comes from workflows.

I’ve seen this across hospitality software, mobile-first products, and other business systems where one change can affect multiple roles and modules at the same time.

The problem

A feature request often sounds simple at first.

Something like:

add one more status
show more data on a screen
allow one more role to access a feature
sync one more step into mobile

But once implementation starts, the real impact appears.

That “small” change can affect:

permissions
reporting
notifications
data validation
mobile UX
admin workflows
audit trails
future integrations

The technical issue is not just how to code it.

The real issue is whether the system has clear enough boundaries to absorb the change cleanly.

What this changed for me

Over time, I’ve become more careful about architecture before implementation.

Not in a heavy, over-designed way.

Just enough to answer a few questions early:

Which module should actually own this logic?
Is this UI behavior leaking business rules into the frontend?
Will this affect reporting or permissions later?
Are we building for the workflow, or just the current screen?
Is this decision going to make the next 10 changes easier or harder?

Those questions have saved me from a lot of avoidable mess later.

Patterns I’ve noticed

1. UI-first thinking creates fragile systems

When a product evolves screen by screen, logic often ends up spread across controllers, components, services, and ad hoc conditions.

It works at first.

Then every change becomes harder because the business rule no longer has a clear home.

2. Roles and workflows create hidden complexity

Business apps are rarely single-user systems.

The same feature can mean different things for an admin, an operator, a manager, or an end customer.

That is where many “simple” features stop being simple.

3. Reporting is often the silent architecture test

A lot of systems feel fine until reporting requirements arrive.

That is usually when weak data modeling and unclear boundaries start to hurt.

4. Mobile surfaces architecture problems faster

In mobile apps, weak backend structure or unclear workflow design becomes visible quickly.

Latency, repeated calls, awkward flows, and state issues show up sooner.

What I try to do now

My default approach is to think in terms of workflows and system boundaries before implementation.

Not because architecture diagrams are the goal.

But because better structure makes iteration easier.

I try to:

map the workflow before finalizing the shape of the feature
keep business rules out of presentation layers as much as possible
think about permissions and reporting earlier
design for change, not just launch
avoid shortcuts that make future changes harder

Final thought

The more “real” the software becomes, the less useful it is to think only in terms of features.

At some point, you have to think in terms of systems.

That shift has changed how I approach product engineering, especially in SaaS, hospitality, and operational software.

What has been the biggest architecture lesson in your own product work?

Rethinking My Portfolio as a Developer

Manthan Bhatt — Mon, 13 Apr 2026 18:56:16 +0000

I’ve been redesigning my portfolio recently, and one thing became very clear to me:
A lot of developer portfolios are built to look nice, but not necessarily to help visitors understand what we actually do.

For a long time, I treated my portfolio like a place to put:

My tech stack
some projects
a bit about me
contact links

But while working on the redesign, I started asking myself a different question:

If someone lands on my site, will they immediately understand how I can help them?

That changed how I started thinking about the whole site.

I’m a full-stack developer, and over the years, I’ve worked on web apps, mobile apps, backend systems, hospitality software, booking engines, admin panels, and product ideas of my own.

The problem is, when you do many things, it becomes easy for your portfolio to feel scattered.

You know your work.
You know the effort behind each project.
You know the technical decisions, the tradeoffs, the debugging, the late changes, the small wins.

But the person visiting your site does not know any of that.

They just want quick answers:

Who are you?
What do you build?
Have you built something similar before?
Can you actually help with my project?

That’s what I’m trying to improve now.

Instead of making the site feel like a resume, I want it to feel more like a clear and honest introduction to my work.

I want the site to show:

What I build
The type of businesses I can help
the kind of problems I’ve solved
and the best way for someone to reach out if they have an idea or a project

I’m also trying to make it more personal.

Not “personal” in the sense of adding random details, but personal in the sense that the site should actually feel like me:
someone who likes building practical products, solving real business problems, and creating software that is useful, maintainable, and scalable.

I’m also exploring adding a guided chatbot/lead form to the site so visitors can describe what they need, explore relevant services or projects, and contact me more easily.

That feels much closer to what I want the portfolio to do:
not just exist, but actually start conversations.

This redesign has reminded me that a portfolio is not only about showing work.

It is also about making your work understandable.

Still a work in progress, but I’m enjoying the process.

What’s one thing you think most developer portfolios get wrong?

Portfolio: https://manthanbhatt.dev/

What code review process do you use for AI-generated code?

Manthan Bhatt — Sun, 12 Apr 2026 19:26:07 +0000

I have been thinking about this a lot lately.

As AI tools become part of daily development, generating code is getting easier. But reviewing that code properly is still very important.

I want to learn how other developers handle this.

When AI generates code for you, what review process do you follow before you keep it?

I am interested in questions like:

Do you review everything line by line?
Do you trust AI for boilerplate only, or also for business logic?
What do you check first: correctness, security, performance, readability, or architecture?
Do you use a checklist?
How do you catch subtle bugs or bad assumptions?

My rough thinking is something like this:

understand the code fully before keeping it
verify logic against requirements
test happy path and edge cases
check security and performance concerns
refactor to match project standards
never merge code only because “it works”

I would really like to hear practical workflows from real developers and teams.

What is your process for reviewing AI-generated code?

DevLaunch - I built a Vercel-inspired dev server manager

Manthan Bhatt — Fri, 20 Mar 2026 07:03:25 +0000

Every developer who works on multiple projects locally knows the pain.
You've got an Ionic app on port 8101, a Laravel API on 8000, and an Angular portal on 4200. That's three terminal tabs, three commands to remember, three processes to track, and the moment you close a terminal by accident, you're back to square one. I built DevLaunch to fix exactly that.

What is DevLaunch?

DevLaunch is a single-file PHP dev server manager with a Vercel-inspired dark UI. You add your local projects, assign them a command and port, and then start, stop, and monitor them all from one browser tab.

No npm install. No composer. No build step. Drop one index.php into any folder served by PHP and open it in your browser.

Features

Single file: the entire app (PHP backend + HTML/CSS/JS frontend) lives in one index.php
Add any project: browse your filesystem server-side (yes, including Windows drives like D:) to select a project folder; the name is auto-detected
Any command: ionic s, npm run dev, ng serve, vite, php artisan serve — whatever you run in the terminal
Custom ports: assign a port per project; the --port flag is auto-appended if not already in your command
Start/Stop: launches as a real detached background process, kills the full process tree on stop (no zombie node processes)
Live log viewer: tail stdout/stderr from any running project in a slide-up terminal panel
Running detection: auto-detects whether a process is still alive after page refresh or system events
Windows + Linux + macOS: works everywhere PHP runs

Quick Start

git clone https://github.com/ManthanBhatt/dev-launch.git

Drop the folder inside your XAMPP/Laragon htdocs (or anywhere served by PHP), then open:

http://localhost/dev-launch/

Or use PHP's built-in server:

cd dev-launch
php -S localhost:8080

That's it.

How it works

The whole thing is a single PHP file that serves two roles depending on the request:
As an API - when a request comes in with the X-DevLaunch-API header, PHP handles actions like start_project, stop_project, browse_dirs, and get_log. Project data is stored in a plain devlaunch_data.json file, and running PIDs are tracked in devlaunch_pids.json.
As the UI - for every other request, PHP outputs the full HTML page with embedded CSS and JavaScript.
Starting a project uses proc_open() to launch the command as a real detached background process in the correct working directory. The process writes its output to a temp log file that the log viewer polls every 2 seconds.

$process = proc_open($p['cmd'], $descriptors, $pipes, $p['path']);
$status  = proc_get_status($process);
$pid     = (int)$status['pid'];

On Windows, it wraps the command in cmd /C so tools like ionic, npm, and ng resolve correctly from PATH. Stopping a project calls taskkill /F /T to kill the entire process tree - no orphan Node processes lingering in Task Manager.

Why PHP?

Honestly, the goal was zero setup. PHP is already running on most local dev environments - XAMPP, Laragon, MAMP, or the built-in server. No runtime to install, no package manager, no compilation. You just put a file somewhere and it runs.
Single-file PHP also means the whole thing is trivially auditable - there are no hidden dependencies, no transitive packages, nothing that phones home. It's ~1,200 lines of code you can read in one sitting.

What's next

Some ideas I'm thinking about for future versions:

Environment variable editor per project
Auto-restart on crash with configurable retry
Multiple commands per project (e.g. spin up a frontend + backend simultaneously with one click)
Export/import project list for sharing across machines

Try it / Contribute

The project is MIT licensed and open source on GitHub:
github.com/ManthanBhatt/dev-launch
If you work on multiple local projects and find this useful, a ⭐ on GitHub goes a long way. PRs, issues, and feature ideas are all welcome.

Built out of frustration with terminal tab juggling. Hope it helps someone else too.Share

What's up?

Manthan Bhatt — Sun, 28 Jul 2024 14:11:18 +0000

Hi,

I hope everyone is having a great relaxing weekend.

I have created this post in intent to connect with the dev all over the world.

You can share things about yourself and things you have been working on or anything that comes to your mind.

I'll start with myself.

I'm Manthan Bhatt. I have been working as a Full stack developer. I love playing games with friends 😁 and explore places with great coffee ☕

Boost Your Productivity as a Developer with OpenAI's ChatGPT

Manthan Bhatt — Fri, 10 Feb 2023 05:32:28 +0000

Introduction:

As a developer, you're constantly searching for ways to increase your productivity and get more done in less time. With the ever-growing demands of the tech industry, it's more important than ever to stay ahead of the curve and work efficiently. Fortunately, OpenAI's ChatGPT provides a solution that can help you increase your productivity and streamline your workflow. In this blog post, we'll explore how ChatGPT can help you boost your productivity as a developer.

Automated Code Generation:

ChatGPT can be trained to generate code based on specific programming languages and frameworks. This can save you hours of time and effort, allowing you to focus on more important tasks. ChatGPT can also generate code snippets, making it easier to quickly implement new features and functionalities.

Documentation and Comments Generation:

ChatGPT can also be trained to generate documentation and comments for your code, making it easier to understand and maintain your code over time. This can save you time and effort in the long run, as well as improving the overall quality of your code.

Research and Data Collection:

ChatGPT can be used to perform research and data collection, allowing you to gather information on specific topics and technologies in a fraction of the time it would take you to do it manually. This can save you hours of time and effort, giving you more time to focus on your coding and development work.

Error Checking:

ChatGPT can also be used to perform error checking and debugging, reducing the amount of time and effort you need to spend on this task. By automating this process, you can spend more time on other important tasks, such as coding and development.

Collaboration:

ChatGPT can be used to collaborate with other developers and team members, allowing you to communicate and share information in real-time. This can improve communication and collaboration within your team, making it easier to get things done and stay on track.

Conclusion:

In conclusion, ChatGPT is a game-changer for developers looking to increase their productivity and streamline their workflow. With its ability to automate code generation, perform error checking, and improve collaboration, ChatGPT is a must-have tool for anyone looking to boost their productivity and get more done in less time. So, why not give it a try and see how it can help you take your productivity to the next level?

5 Reasons Why GraphQL is the Future of API Development

Manthan Bhatt — Thu, 09 Feb 2023 03:45:25 +0000

Introduction:

API development is a crucial aspect of modern web development, as it allows communication between the frontend and the backend. Over the past few years, the popularity of GraphQL has skyrocketed, making it one of the most talked about topics in the tech industry. In this blog post, we will discuss five reasons why GraphQL is the future of API development.

Flexibility: GraphQL offers a highly flexible approach to API development, as it allows developers to request exactly the data they need. This means that the client can specify exactly what information it requires, resulting in a more efficient and effective API.
Ease of use: GraphQL is incredibly easy to use, as it eliminates the need for multiple round trips to the server. This results in a much simpler and faster API, as well as reducing the amount of code required to make API calls.
Strong type system: GraphQL has a strong type system that allows developers to define the structure of the data being transmitted between the client and server. This type system helps catch potential errors early in the development process, reducing the likelihood of bugs and unexpected behavior.
Improved performance: With GraphQL, clients are able to fetch multiple resources in a single request, as opposed to multiple requests in traditional REST APIs. This can greatly improve performance and reduce server load, especially in cases where a lot of data is needed.
Growing community: GraphQL has a growing and passionate community of developers, who are constantly contributing to its development and improvement. With a large number of companies and projects already using GraphQL, it has a bright future and is here to stay.

Conclusion:

In conclusion, GraphQL offers numerous benefits over traditional REST APIs, including greater flexibility, ease of use, a strong type system, improved performance, and a growing community of developers. As the technology continues to evolve and mature, it's likely that we'll see an even greater adoption of GraphQL in the future. If you haven't already, it's time to start exploring the benefits of GraphQL and see how it can improve your API development process.

Why Ionic and Capacitor are the Future of Cross-Platform Mobile Development

Manthan Bhatt — Wed, 08 Feb 2023 07:38:48 +0000

Introduction:

Mobile development has come a long way in recent years, with a multitude of options available for building cross-platform apps. One such framework that has gained a lot of attention lately is Ionic, along with its accompanying runtime Capacitor. In this blog post, we'll explore why Ionic and Capacitor are the future of cross-platform mobile development.

Native Experience: Ionic and Capacitor make it possible to build apps that deliver a truly native experience on both iOS and Android platforms. With the ability to access native device features and functionality, such as camera, accelerometer, and more, Ionic and Capacitor apps are indistinguishable from native apps.
Code Reusability: Ionic allows developers to write code once and run it on multiple platforms, reducing the time and effort required to build and maintain separate codebases for iOS and Android. This can save a significant amount of time and money, especially for small teams and startups.
Performance: With Capacitor as the underlying runtime, Ionic apps have the performance and speed of native apps, without sacrificing the ease of development offered by cross-platform frameworks. Capacitor's architecture allows it to bridge the gap between web and native, providing the best of both worlds.
Large Community: Ionic has a large and active community of developers, who constantly contribute to its development and improvement. With over 5 million developers worldwide, the Ionic community is a valuable resource for anyone looking to build cross-platform apps.
Plugins and Tools: Ionic and Capacitor come with a vast array of plugins and tools, allowing developers to easily add functionality and enhance their apps. From push notifications to geolocation, these plugins make it simple to add native-like features to your app.

Conclusion:

In conclusion, Ionic and Capacitor are the future of cross-platform mobile development. With the ability to deliver a truly native experience, save time and effort with code reusability, offer high performance, a large community of developers, and a range of plugins and tools, it's no wonder why so many developers are choosing Ionic and Capacitor. Whether you're a seasoned developer or just starting out, now is the perfect time to dive into Ionic and Capacitor and start building amazing cross-platform apps.

How I can go to the next level?

Manthan Bhatt — Wed, 14 Sep 2022 06:12:44 +0000

Working as software developers many times we have questions in mind about how I can move to the next level. Or what new skill should I learn so that I can move forward in my career?

If we don't have a clear idea or vision of what to do then we feel stuck while working which became a bottleneck for our success in our career life.

Let's discuss some potential ways of how we can move forward when you get to a certain level in your career when you don't have a clear vision of what to do now.

Suggest me something for reading

Manthan Bhatt — Tue, 23 Aug 2022 05:53:21 +0000

I want to learn the fundamentals of programming and other concepts from the base with the following topics:

Data Structure and Algorithms
System Design
AI
ML
Cloud

Please do suggest me material which will be great to learn the things.
I'm also open to video material or other type of content

Feel free to share your experience while learning the mentioned thing which will be helpful to me and people encountering this post.

Let's discuss it!

What things you do for starting new project?

Manthan Bhatt — Sat, 06 Aug 2022 06:56:12 +0000

I was curious about what a developer do when they start any new project that they are interest in building.

Are there any rituals that they follow for starting new project?

How they plane the initial development for the project?

Let's discuss it!

Implement Binary Search Using JavaScript

Manthan Bhatt — Tue, 12 Jul 2022 04:36:59 +0000

Binary search technique is used to search for any element in a sorted array using divide and conquer approach.

/**
 * Binary Search
 * Note - It works only for the sorted array. start and end are left and right of the array.
 *
 * Recursive Approach
 * - If starting index is greater than the ending index return false
 * - Compute the middle index.
 * - Compare the middle element with the number x. If equal return true.
 * - If greater, call the same function with ending index = middle-1 and repeat step 1.
 * - If smaller, call the same function with starting index = middle+1 and repeat step 1.
 * 
 * Time Complexity: O(logN)
 * Auxiliary Space: O(1)
 */

const arr = [1, 3, 5, 7, 8, 9];

const binarySearchRecursive = (arr, val, start, end) => {
    if (start > end) return false;

    const mid = Math.floor((start + end) / 2);

    if (arr[mid] === val) return mid;

    const left = arr[mid] > val ? start : mid + 1;
    const right = arr[mid] > val ? mid - 1 : end;

    return binarySearchRecursive(arr, val, left, right);
}

console.log(binarySearchRecursive(arr, 5, 0, arr.length - 1)); // -> 2