DEV Community: Imam Ali Mustofa

AI Can Write the Code. So What Are You Actually Good At?

Imam Ali Mustofa — Wed, 02 Sep 2026 18:02:34 +0000

There is a strange thing happening in software engineering.

We have AI that can generate functions, explain stack traces, write SQL queries, scaffold APIs, refactor code, write tests, and even build entire applications from a single prompt.

And somehow, this makes me more convinced than ever that software engineers need strong fundamentals.

Not less.

More.

Because when writing code becomes cheap, understanding code becomes expensive.

The uncomfortable part about AI-assisted development

Let's say you ask an AI:

"Build me a REST API for managing users."

Five seconds later, you have controllers, models, routes, validation, authentication, tests, and probably a Docker configuration.

Nice.

But then something breaks.

The database starts timing out.

Your queue keeps retrying the same job.

Memory usage slowly climbs.

A race condition appears only under production traffic.

Your API returns inconsistent data.

The AI gives you three possible fixes.

All three sound reasonable.

Now what?

This is where fundamentals suddenly become very expensive.

If you don't understand HTTP, databases, concurrency, operating systems, networking, data structures, algorithms, application architecture, and the runtime you're working with, you don't really have an AI-assisted development workflow.

You have an AI dependency.

And that's a very different thing.

AI is very good at generating code

We should acknowledge this.

AI is incredibly useful.

I use it.

I experiment with it.

I ask it stupid questions.

I let it generate boring code.

I let it explain unfamiliar APIs.

I use it as a second pair of eyes.

Sometimes I even let it write the first ugly version of something.

That's fine.

Software engineering has always been about using tools.

Compilers replaced handwritten machine code.

Frameworks replaced enormous amounts of boilerplate.

Libraries replaced reinventing common algorithms.

Cloud platforms replaced maintaining physical servers.

AI is simply another abstraction layer.

But abstraction has a price.

You can only safely abstract away something you understand well enough to debug when the abstraction fails.

That's the part people often forget.

The code is not the software

This is probably one of the most important distinctions for new engineers.

A software system is not just source code.

A system is a combination of:

requirements
data
algorithms
state
interfaces
networks
databases
operating systems
infrastructure
security
humans
and a lot of assumptions nobody documented

AI can generate the code.

It cannot magically remove the complexity underneath it.

You still need to understand what the generated code is doing.

Otherwise, you're basically driving a race car while asking the passenger which pedal is the brake.

Fundamentals give you a mental debugger

One of the biggest advantages of learning fundamentals is that they give you a way to reason.

Suppose an API suddenly becomes slow.

A beginner might ask an AI:

"Why is my API slow?"

An engineer starts breaking the problem apart.

Is the application slow?

Is the database slow?

Is the network slow?

Are we making too many queries?

Is there an N+1 query problem?

Are we waiting on an external service?

Is the CPU saturated?

Is memory under pressure?

Are connections exhausted?

Is the queue backed up?

Is the algorithm doing unnecessary work?

This is not about memorizing solutions.

It's about knowing where to look.

Fundamentals turn debugging from guessing into investigation.

Learn algorithms even if AI can write them

"But I don't need to learn algorithms anymore. AI can generate them."

Sure.

And a calculator can calculate 927 × 381.

You should still understand multiplication.

The point of learning algorithms isn't to prove that you can manually implement a sorting algorithm during an interview.

The deeper value is learning how to think about computational problems.

You start asking:

What happens when the dataset becomes 10x larger?

What is the time complexity?

What is the memory cost?

Can this operation be indexed?

Can this process be parallelized?

Do I actually need to process all of this data?

These questions matter even when AI writes the implementation.

In fact, they matter more when AI writes the implementation.

Because AI can produce code that is perfectly valid and completely unreasonable.

Learn databases before letting AI design your database

This one hurts because I've seen it too many times.

Someone asks AI to create a database schema.

AI happily generates seventeen tables, twelve relationships, several indexes, some JSON columns, and a migration nobody understands.

Everything works.

Until production.

Now suddenly:

SELECT * FROM users

is running across millions of rows.

The ORM is generating hundreds of queries.

An index is missing.

A transaction boundary is wrong.

A foreign key relationship doesn't represent the actual business rule.

The database becomes the bottleneck.

The solution isn't another prompt.

The solution is understanding databases.

You don't need to become a database researcher.

But you should understand:

indexes
primary keys
foreign keys
joins
transactions
isolation
normalization
query plans
constraints
locking
pagination

AI can help you write SQL.

You still need to understand why the SQL is correct.

Learn networking

Modern software is distributed by default.

Your application talks to something.

Maybe it's a database.

Maybe it's Redis.

Maybe it's an external API.

Maybe it's object storage.

Maybe it's another microservice.

Maybe it's some random service running on a server you forgot existed.

At some point, something goes through a network.

Understanding basic networking gives you an entirely different perspective on software.

HTTP isn't magic.

DNS isn't magic.

TCP isn't magic.

TLS isn't magic.

A timeout isn't just "the server is broken."

Latency exists.

Packets get lost.

Connections get reused.

Proxies exist.

Load balancers exist.

Caches exist.

Once you understand these things, production errors become less mysterious.

Learn your operating system

You don't need to become a kernel developer.

But please learn what happens outside your editor.

Processes.

Threads.

Memory.

File descriptors.

Signals.

Permissions.

Sockets.

Environment variables.

Processes getting killed.

Logs.

CPU usage.

Memory pressure.

Disk I/O.

This knowledge becomes extremely useful the first time your application works perfectly on your laptop and behaves like a haunted machine in production.

Your framework is not the operating system.

Your framework is a layer on top of reality.

And reality doesn't care how elegant your abstractions are.

AI makes shallow knowledge more dangerous

This is the part I worry about the most.

AI makes it incredibly easy to appear productive.

You can generate a lot of code without understanding much of it.

That's dangerous because productivity can become an illusion.

You create a repository.

There are thousands of lines of code.

The README looks beautiful.

The tests are green.

The UI works.

Everything feels like engineering.

Until someone asks:

"Why did you design it this way?"

And the answer is:

"Because the AI suggested it."

That's not engineering.

That's delegation without accountability.

An engineer can delegate implementation.

An engineer cannot delegate responsibility for understanding the system.

The new skill isn't "prompt engineering"

Prompting is useful.

But I don't believe prompt engineering is the foundation of AI-era software engineering.

The real skill is context engineering.

Can you understand the problem?

Can you define constraints?

Can you provide the right context?

Can you recognize incorrect assumptions?

Can you evaluate the generated result?

Can you test it?

Can you observe it in production?

Can you explain the trade-offs?

Can you throw the generated solution away when it's wrong?

That requires knowledge.

A better prompt cannot compensate for a missing mental model.

The fundamentals become your filter

Think of AI as an extremely fast junior engineer who has read an absurd amount of documentation but doesn't actually have your production environment inside its head.

It can be brilliant.

It can also confidently produce nonsense.

Your job is to build the filter.

When AI gives you an answer, you should be able to think:

"That sounds wrong because..."

Or:

"That's technically correct, but the trade-off is..."

Or:

"This works for 10,000 records, but it will become a problem at 100 million."

Or:

"This abstraction hides the exact thing I need to control."

That little voice is engineering judgment.

And engineering judgment comes from fundamentals plus experience.

Don't become a code typist

I think the role of the software engineer is changing.

The ability to type syntax quickly is becoming less valuable.

The ability to understand systems is becoming more valuable.

The engineer of the future doesn't necessarily write more code.

They might write less.

They might spend more time:

defining problems
designing systems
investigating failures
validating assumptions
reviewing generated code
designing experiments
analyzing data
improving developer experience
simplifying architecture
removing unnecessary code

Ironically, AI might make good engineers look less productive on GitHub.

Because sometimes the best engineering decision is:

Don't build it.

Learn the boring stuff

If you're starting your software engineering journey today, here's my unpopular advice:

Don't spend all your time chasing the newest AI framework.

Learn the boring stuff.

Learn how a CPU executes instructions.

Learn how memory works.

Learn Linux.

Learn networking.

Learn HTTP.

Learn databases.

Learn algorithms.

Learn data structures.

Learn Git.

Learn testing.

Learn debugging.

Learn how to read documentation.

Learn how to read source code.

Learn how to design an API.

Learn how to model data.

Learn how to observe a running system.

Then use AI.

Use it aggressively.

Use it as a pair programmer.

Use it as a teacher.

Use it as a reviewer.

Use it to generate the boring parts.

Use it to challenge your assumptions.

Just don't let it replace your ability to think.

The paradox of AI

Here is the paradox I keep coming back to:

The better AI becomes at writing software, the more important it becomes to understand software.

Because generated code increases the amount of code we can produce.

It doesn't automatically increase our ability to judge that code.

And when the cost of producing code approaches zero, the bottleneck moves somewhere else.

The bottleneck becomes:

judgment.

What should we build?

Why?

What should we not build?

Is this architecture appropriate?

Is this data model correct?

Is this secure?

Is this maintainable?

What happens when it fails?

What happens when traffic grows?

What happens when the assumptions change?

Those are not syntax questions.

They're engineering questions.

Go beyond the code

I'm not anti-AI.

Quite the opposite.

I'm interested in what happens when we combine human curiosity with machines that can generate software at ridiculous speed.

But I don't want a generation of developers who know how to ask an AI for code but don't know how that code interacts with reality.

That's backwards.

Learn to think.

Learn to investigate.

Learn to build things from first principles.

Break things.

Read the error messages.

Read the source code.

Build the weird little tool nobody asked for.

Build it again when you realize your first architecture was terrible.

That's how you develop engineering intuition.

AI can accelerate that journey.

It cannot walk it for you.

And maybe that's the most important thing to remember in this new era:

Don't compete with AI at writing code. Become the person who knows what code should exist in the first place.

I Build libSQL Server Web GUI - MylibSQLAdmin

Imam Ali Mustofa — Fri, 20 Jun 2025 19:39:59 +0000

MylibSQLAdmin - A Modern libSQL Database Management Platform

Hello Punk! If you’ve ever wrestled with SQLite databases, felt buried under clunky UIs, or just wished your database tools were as sleek as your favorite apps—say hello to MylibSQLAdmin. It’s like giving your SQLite workflow a double shot of espresso ☕️, but without the jitters. That's it no punchline!

What’s the Big Deal?

First off, MylibSQLAdmin isn’t just another SQLite manager. It’s built for libSQL—a turbocharged fork of SQLite designed for modern apps (think serverless mode, granular permissions, and even database share schema 🌿). And guess what? MylibSQLAdmin wraps all that power into a smooth, web-based UI. No PhD in CLI required.

Here’s the vibe:

Stats That Don’t Suck: Get instant database insights without drowning in spreadsheets.
Token & Team Management: Secure your DB like a VIP club 🕶️—tokens, groups, user roles, all in one place.
Zero-Fuss Collaboration: Invite teammates, manage permissions, and keep everyone rowing in the same boat 🚣.
libSQL’s Superpowers: Play with serverless or server mode, shared schema databases, and more.

Oh, and it’s open-source. Because sharing is caring.

Why did I build MylibSQLAdmin?

Simple — I love a good challenge.

Managing databases with sqld (libsql-server) wasn’t as smooth as I wanted it to be. Sure, Turso (the company behind it) already offers a platform for database management.

But here's the thing:

I wanted something I could run myself.
On my own server.
With full control.

So, I built my own platform — MylibSQLAdmin — to make managing libSQL easier and more accessible for folks like me.

Sure, it’s not on the same level as what Turso’s platform offers — and that’s okay.

Why?
Because what I’ve built already covers what I need. And honestly, that’s enough for me.

So, what makes it “enough”?

User Management: I needed a way to let multiple users access the platform. Now it can.
Team Management: Working with a team gets way easier when you can assign roles, group access, and keep things organized.
Group Database Management: This lets smaller teams work only with the databases meant for them. No more clutter.
Token Management: For remote connections to libSQL (like in serverless setups), token-based access is a must — and now it’s built in.

And a bunch of other small things that just make managing libSQL databases smoother and less of a headache.

darkterminal / mylibsqladmin

MylibSQLAdmin - A Modern libSQL Database Management Platform

A Modern SQLite Database Management System

In the age of data-driven applications, the demand for lightweight, scalable, and modern database solutions has never been greater. libSQL is a powerful fork of SQLite designed for the modern era, offering advanced features such as serverless and server-based modes, fine-grained access control, and native branching capabilities.

MylibSQLAdmin is an open-source web GUI built specifically for managing libSQL databases. By harnessing the full potential of libSQL-server functionalities, this project provides an intuitive and comprehensive platform for database administration, making it easier than ever to manage your database systems through an accessible web interface. You can connect with libsql-server from Docker Service or use your existing libsql-server instance.

View on YouTube

What Does MylibSQLAdmin Offer?

Simple Database Statistics - Get quick insights into your database performance with easy-to-understand stats.
Database Management - Create, edit, and manage your databases with intuitive tools.
Token Management - Secure…

View on GitHub

From Fun to Frustration: A Lone Wolf in the Open Source World

Imam Ali Mustofa — Thu, 27 Feb 2025 18:56:09 +0000

Hello Punk! I am darkterminal a Software Freestyle Engineer.

Someone who has forgotten how to sleep.

A Day after Having Fun

After dancing with Whatsback Web for almost three weeks, I’ve finally poured out every distraction in my mind. I feel relieved—and even more handsome and charming!

As an S.F.E, I’m incredibly proud to be part of the Open Source community and this digital-ephemeral world. After all, expression and innovation should always be channeled and released in the right place.

Back To Open Source Work

“Work”? Sure, let’s call it that—even though “work” usually comes with some kind of financial reward. But in all the chaos I’ve stirred up in this digital world, I haven’t gotten much support, let alone compensation. Sometimes, I wonder—can someone like me, a troublemaker, ever really find a place in this fleeting online existence?

At the end of the day, I’ve realized that nothing is impossible in this ever-changing digital space. Hard work and a bit of madness always seem to bring some kind of response from the universe. Maybe it just hasn’t happened for me yet. Or maybe I’m just too unconventional—so much so that I come off as weird or even completely out of place. Who knows?

What I've Done Before?

If you visit my GitHub profile, you’ll probably feel a bit weirded out and think to yourself, “What kind of crazy person is this?” And you’d be right! What kind of crazy person am I? That’s something I hear all the time from people around me. But that’s okay—this is the path I’ve chosen. What most people don’t realize, though, is that deep down, I’m lonely and could really use some support.

In my non-technical life, I’m doing just fine. But in the Open Source world, I’m a lone wolf. Why? Just take a look at my projects—you’ll see how solitary this journey has been. I’m not looking for pity. What I dream of is collaboration—a little toxic, a little fun, just mischievous enough to talk about silly, pointless things in this fleeting digital world.

Let's talk!

I created Whatsback Web with simple features and made it free and open source. So, what did I get in return? What I got was the realization of how and who truly appreciates the hard work behind a creation.

Imam Ali Mustofa — Wed, 26 Feb 2025 11:08:13 +0000

Imam Ali Mustofa

Feb 24 '25

Whatsback Web: Automate WhatsApp with Power & Responsibility

#webdev #javascript #api #programming

5 min read

It's Free and Open Source!

Imam Ali Mustofa — Tue, 25 Feb 2025 09:19:34 +0000

Imam Ali Mustofa

Feb 24 '25

Whatsback Web: Automate WhatsApp with Power & Responsibility

#webdev #javascript #api #programming

5 min read

Whatsback Web: Automate WhatsApp with Power & Responsibility

Imam Ali Mustofa — Mon, 24 Feb 2025 18:30:00 +0000

Hello Punk! I am darkterminal a Software Freestyle Engineer. Let’s cut to the chase: WhatsApp automation is a double-edged sword. We all crave tools to streamline messaging, but dancing with unofficial APIs is risky business. Today, I’m pulling back the curtain on Whatsback Web—a project born from late-night coding sessions and a stubborn refusal to accept "impossible." But first: this isn’t a fairy tale. Use it wisely, or face the wrath of WhatsApp’s banhammer.

Why I Built Whatsback Web?

You Can Dive Deeper in My Previous Blog. This project has been my playground ever since whatsapp-web.js first hit the scene. It’s been a wild, fun ride—like a high-stakes game of cat and mouse. Sure, I’ve sacrificed a lot of phone numbers along the way (RIP to those brave souls). But here’s the thing: I’ve learned, observed, adapted, and most importantly—I’ve survived.

Imam Ali Mustofa

Feb 21 '25

Why I Built Whatsback Web—And Why It’s Different From Other Tools

#webdev #automation #whatsapp #opensource

3 min read

This isn’t just a project; it’s a testament to stubbornness and curiosity. Every ban, every roadblock, every “this shouldn’t work” moment has been a lesson. And now, I’m here to share the spoils of that battle with you.

It’s gonna be a bumpy ride—but hey, that’s where the fun is.
darkterminal - The guy who refuses to quit.

Who Likes Spam?!

Let me be clear: I hate spam. It’s annoying, disruptive, and downright infuriating. No wonder WhatsApp comes down hard with those permanent bans. Imagine this: a brand-new number with zero interaction history suddenly blasting out a flood of messages and hammering the server with requests. Damn, that’s just unfair.

Spam isn’t just a nuisance—it’s a violation of trust. It clogs up the system, ruins the experience for everyone. That’s why I’ve built this project with restraint in mind. It’s not about spamming; it’s about smart, responsible automation.

So, if you’re thinking of using this tool to flood people’s chats, think again. Play nice, or face the consequences. WhatsApp doesn’t mess around, and neither should you.

Using WhatsApp Web

This project is built on top of whatsapp-web.js—a library that gives you superpowers to interact with WhatsApp Web programmatically. No heads, no hassle. But don’t expect a ton of crazy features here. Why? Because I’ve already gone crazy enough building this thing.

The whole point of Whatsback Web is to give you a useful tool to save time in your business. It’s about efficiency, not overcomplication. With its REST API, you can forward messages, send automated texts, and integrate it seamlessly into your website or app.

await fetch(`${WHATSBACK_URL}/api/message/send-message`, {
  method: "post",
  headers: {
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    number,
    message: job.message,
  }),
});

Getting Started

There is 2 way to install and use Whatsback Web

Docker (The Easy Way)

When using docker installation you've 2 options, using Docker CLI or Docker Compose.

Docker CLI

Pull the image:

   docker pull ghcr.io/darkterminal/whatsback-web:latest

Create Network

  docker network create whatsback-net

Create Volume

  docker volume create whatsback-db

Run Whatsback Application Container

  docker run -d \
    --name whatsback-app-provider \
    --network whatsback-net \
    -p 8169:5001 \
    -e NODE_ENV=production \
    -e APP_PORT=5001 \
    -e DB_PATH=/data/database.sqlite \
    -v whatsback-db:/data \
    ghcr.io/darkterminal/whatsback-web:latest

Run Whatsback Cronjob Container

  docker run -d \
    --name whatsback-app-cronjob \
    --network whatsback-net \
    -e NODE_ENV=production \
    -e APP_HOST=whatsback-app-provider \
    -e DB_PATH=/data/database.sqlite \
    -v whatsback-db:/data \
    ghcr.io/darkterminal/whatsback-web:latest \
    sh -c "./wait-for whatsback-app-provider:5001 -t 120 -- node cronjob.js"

Docker Compose

# docker-compose.yml or compose.yml
services:
  app:
    image: ghcr.io/darkterminal/whatsback-web:latest
    container_name: whatsback-app-provider
    ports:
      - "${UI_PORT:-8169}:5001"
    environment:
      - NODE_ENV=production
      - APP_PORT=${APP_PORT:-5001}
      - DB_PATH=/data/database.sqlite
    volumes:
      - db-data:/data
    networks:
      - app_net
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:$$APP_PORT/health || exit 1"]
      interval: 15s
      timeout: 10s
      retries: 5

  cronjob:
    image: ghcr.io/darkterminal/whatsback-web:latest
    container_name: whatsback-app-cronjob
    environment:
      - NODE_ENV=production
      - APP_HOST=app
      - DB_PATH=/data/database.sqlite
    volumes:
      - db-data:/data
    command: sh -c "./wait-for app:5001 -t 120 -- node cronjob.js"
    networks:
      - app_net
    depends_on:
      app:
        condition: service_healthy

networks:
  app_net:
    driver: bridge

volumes:
  db-data:

Source Installation

git clone https://github.com/darkterminal/whatsback-web.git  
cd whatsback-web  
npm install  
NODE_ENV=production node server.js

🔐 The Elephant in the Room: Security & Risks

Let’s be blunt:

WhatsApp hates bots (Me too). Using this could get your account banned.
We’ve added armor (Helmet, rate-limiting), but no guarantees.
This project isn’t affiliated with WhatsApp. Use at your own risk.

☕ Support the Madness

Building tools like this burns caffeine and sanity. If Whatsback Web saves you time:

GitHub Sponsors - International Supporter
Saweria - Indonesian Supporter

Checkout The Whatsback Web - GitHub Repository

🚨 Final Warning

This isn’t a toy. It’s a proof-of-concept for developers who understand the risks. If you’re looking for a “safe” solution, walk away.

🔥 Tips to Survive the WhatsApp Jungle

Let’s keep it real: using Whatsback Web isn’t a free pass to go wild. WhatsApp’s algorithms are watching, and they don’t play nice. Here’s how to stay under the radar and keep your account alive:

Age Matters:

Make sure the number you’re using is at least 2 weeks old (my personal sweet spot is 1 month). Fresh numbers scream “bot” and get slapped with bans faster than you can say “Oops.”
Keep It Active:

Use a number that’s actively used for daily interactions. Dormant numbers are red flags. WhatsApp loves activity—so give it what it wants.
API Etiquette:

Use the REST API wisely. Don’t bombard the server with endless requests. Space them out, be patient, and don’t whine when things don’t go your way.
No Spam, Ever:

This can’t be stressed enough. Avoid spam like the plague. It’s not just annoying—it’s a one-way ticket to Bannedville.

Remember:

This isn’t about gaming the system—it’s about working smarter. Play by the rules, and Whatsback Web will be your best friend. Break them, and well… good luck explaining to your boss why your WhatsApp account got nuked.

Stay smart,

darkterminal

The guy who’s been there, done that, and lived to tell the tale.

Disclaimer: Follow these tips, or prepare to face the consequences. Your call.

Did you know about this?

Imam Ali Mustofa — Fri, 21 Feb 2025 17:18:24 +0000

Imam Ali Mustofa

Feb 21 '25

Why I Built Whatsback Web—And Why It’s Different From Other Tools

#webdev #automation #whatsapp #opensource

3 min read

Why I Built Whatsback Web—And Why It’s Different From Other Tools

Imam Ali Mustofa — Fri, 21 Feb 2025 04:11:11 +0000

I built Whatsback Web out of frustration—frustration with endless WhatsApp notifications, manual reports, and missed deadlines. As a Software Freestyle Engineer, I needed a way to automate routine tasks like sending daily updates, rotating team passwords, and managing group announcements without being tied to expensive platforms or complex coding. Other solutions demanded steep subscriptions, locked me into proprietary systems, or required technical know-how I simply didn’t have time to master (too lazy). That’s when I decided: why not build my own tool and share it with everyone? (look very kind and nice idea!)

The Breaking Point: “There Has to Be a Better Way”

Every day, my workflow looked like this:

Manually forwarding booking forms from clients.
Copy-pasting daily reports into multiple group chats.
Resetting weekly passwords for team accounts (and praying I didn’t forget).

I wasn’t alone. Many businesses, freelancers, and community admins face the same chaos. In my search for solutions, I found:

Enterprise tools (like Twilio’s API): Powerful, yet expensive and code-heavy.
No-code platforms (such as WATI or Chatfuel): User-friendly, but their subscription fees quickly add up.
DIY scripts: Customizable but time-consuming to maintain and fragile against WhatsApp updates.

So I asked myself: What if there was a free, open-source backend that anyone could adapt—no strings attached?

Building Whatsback Web: A Tool for Myself (and You)

I’m building Whatsback Web with whatsapp-web.js—a robust library that allows me to interact seamlessly with WhatsApp Web. This lets me harness powerful automation features without reinventing the wheel. I built Whatsback Web around three core principles:

Simple-Straightforward UI: Let User find and configure they needs.
Complete Ownership: Host it yourself, control your data, and avoid vendor lock-in.
Zero Cost: Free forever, with no hidden fees or tiered pricing.

For instance, I automated my team’s weekly password rotations by connecting Whatsback API (built-in) that integrated into another application script. Booking forms now auto-forward to responsible accounts, and scheduled group announcements go out—even if I’m offline. It’s like having a personal assistant that works 24/7 without costing a dime.

How It Stacks Up Against Other Tools

Here’s a practical comparison:

Feature	Whatsback Web	Twilio API	WATI / Chatfuel
Cost	Free (self-hosted)	Pay-per-message + API fees	Monthly subscription
Customization	Full control (open-source)	Requires coding	Limited by platform features
Data Ownership	Your server, your rules	Third-party servers	Third-party servers
Ease of Setup	Basic tech skills needed	Developer expertise needed	Drag-and-drop interface

The trade-off? Whatsback Web might not be as flashy as some paid tools, but it’s infinitely adaptable. Need to integrate with a niche app? You can do it. Concerned about privacy? Host it on your own hardware. It’s a toolkit designed to empower you, not a black box that dictates your workflow.

Why I Open-Sourced It (And Why That Matters)

I chose to open-source Whatsback Web for two key reasons:

Community-Driven Innovation: Open-source projects thrive on collaboration. Developers can improve security, add integrations, or fix bugs that I might overlook.
Transparency: With no hidden trackers or data harvesting, you can review and audit the code yourself. Trust comes from openness.

There’s also a personal side: sharing this project has connected me with developers around the globe, inspiring innovative use cases—like nonprofits using it to coordinate disaster relief updates.

Your Turn: Automate Without Limits

Whatsback Web isn’t about being “the best” tool on the market—it’s about being the most flexible. It’s perfect for:

Small businesses tired of paying for unnecessary features.
Tech-curious users eager to explore self-hosted solutions.
Developers looking for a customizable foundation to build upon.

If you’ve ever thought, “I wish WhatsApp could just do this,” then Whatsback Web is the tool for you. No permissions, no barriers—just endless possibilities.

Support the Project

If you find Whatsback Web valuable, consider supporting its ongoing development:

Worldwide: GitHub Sponsors (darkterminal)
Indonesian Supporters: Saweria (darkterminal)

Your contributions help fuel new features, continuous improvements, and a vibrant community of contributors.

Ready to take control?

👉 Grab the code on GitHub and make it your own.

— A man who wanted fewer notifications and more sleep

P.S. This isn’t a “launch”—it’s an invitation to build something better, together.

From Express to Laravel: My Journey of Rewriting a 5-Year-Old REST API (and Surviving the Chaos)

Imam Ali Mustofa — Sun, 26 Jan 2025 05:06:08 +0000

If you’ve ever been handed the task of rewriting a legacy system, you know it’s like being asked to rebuild a plane while it’s still in the air. For the past four days, I’ve been knee-deep in the trenches, converting a 5-year-old Express REST API into a shiny new Laravel 11 REST API. And let me tell you—it’s been a wild ride.

Starting with the Hard Things First

As Taylor Otwell, the creator of Laravel, wisely said, “Start with the hard things first!” And boy, did I take that advice to heart. The first hurdle? Creating 64 table schemas in Laravel from an existing database. If that doesn’t sound like a nightmare, you’ve probably never had to manually map out decades of database decisions made by someone who clearly didn’t believe in documentation.

It was a pain in the ass, but oddly satisfying. There’s something therapeutic about taking chaos and turning it into order. And thanks to my new assistant, Deepseek AI, the process felt a little less like pulling teeth and a little more like solving a puzzle.

The Real Challenge: Controllers and Models

Now that the database schemas are done, the next mountain to climb is converting all the controllers and models from Express to Laravel. If you’ve ever worked with both frameworks, you know they’re like two different languages—Express is the wild west, and Laravel is the well-organized city with traffic lights and sidewalks.

This part is going to be intense. But hey, if I survived creating 64 table schemas, I can survive this too, right?

The Fun Part: Backup Script Magic

Amidst all the chaos, there’s been one bright spot: converting the Backup Script from native PHP to Laravel. This little gem takes a database dump, transforms it into an image, and stores it in Cloudflare R2 Object Storage.

Why? Because I’m a poor man. Let’s be real—Cloudflare’s 10GB of free storage isn’t exactly a bottomless pit. So, I had to get creative. By minimizing the size of the database dumps, I can stretch that 10GB as far as possible. It’s like playing Tetris with data, and honestly, it’s been the most enjoyable part of this whole process.

Lessons Learned (So Far)

Start with the hard things. It’s tempting to tackle the easy tasks first, but getting the tough stuff out of the way early makes the rest of the project feel like a downhill sprint.
Document everything. If you’re working with a legacy system, chances are the original developers didn’t leave you much to work with. Don’t make the same mistake—document your process as you go.
Leverage AI tools. Tools like Deepseek AI have been a game-changer for me. They don’t replace the need for human intuition, but they sure make the grind a lot easier.
Celebrate the small wins. Whether it’s successfully converting a backup script or finally getting that one stubborn table schema to work, take a moment to appreciate your progress.

What’s Next?

The journey isn’t over yet. Converting the controllers and models is going to be a beast, but I’m ready for it. And who knows? Maybe by the end of this, I’ll have a few more war stories to share.

If you’ve ever gone through a similar rewrite, I’d love to hear about your experience. And if you’re just starting one, buckle up—it’s going to be a bumpy ride, but it’s worth it.

Until next time, happy dancing!

What’s the most challenging rewrite or migration project you’ve tackled? Let me know in the comments below!

Lil Story about libSQL Extension in PHP

Imam Ali Mustofa — Sat, 25 Jan 2025 05:31:03 +0000

Who's the Creator of the libSQL Extension in PHP? Spoiler: It's Me!

Let me share a quick story. The other day, someone messaged me on social media. They sent a screenshot asking, “Who’s the creator of the libSQL extension in PHP?”

Well, guess what? It’s me.

Yep, me. The same person who talks about libSQL and Turso Database everywhere. Why not? It's my work (even though I'm not Turso Internal). If that sounds a bit full of myself, I’ll admit it. That’s just how I roll.

Now, about this Software Freestyle Engineer (SFE) title. Sounds fancy, right? But really, it’s a bit of a joke. I mean, it’s true, but still a joke. I don’t fit into the typical mold. I’m the guy who bends the rules, writes some code, and laughs about it later.

Being an SFE is all about embracing the wild side. It takes guts to try what others won't. And sure, I like to think I make it look easy. I’m not here to follow the crowd—I’m here to change the game.

So, when people ask about the libSQL extension, I don’t just give them a boring answer. I show them me. This extension wouldn't exist without my mix of boldness and a bit of charm. I’m someone who takes risks, makes mistakes, and then shares it online.

So there you have it. If you've wondered who's behind the libSQL extension in PHP, it's me. The SFE. A mix of humor and smarts. The one who makes things happen.

Honestly? I wouldn’t change a thing.

Catch you later, folks!

☕️ Support My Work at GitHub

tursodatabase / turso-client-php

Turso + PHP - libSQL Extension for PHP (Community SDK)

Turso Client PHP

A community-driven PHP SDK for libSQL — the SQLite fork designed for the edge, replication, and production workloads

Overview

turso-client-php (libSQL Extension) brings the power of libSQL to PHP applications. It’s more than just SQLite — with built-in support for remote connections, replicas, sync, offline writes, and transactions.

✨ Key features:

🚀 Works with SQLite and libSQL
🔌 Multiple connection modes
- local
- in-memory
- remote
- remote replica
- offline-writes also support for libsql-server (sqld)
🔒 Transactions, prepared statements, and batch execution
🐘 Native PHP extension built in Rust for speed
🐳 Easy setup with turso-php-installer

Supported Versions

PHP Versions	Build Versions
8.1	TS / NTS
8.2	TS / NTS
8.3	TS / NTS
8.4	TS / NTS
8.5	TS / NTS

TS = Thread Safe, NTS = Non Thread Safe
✅ Supported on Linux, macOS, Windows, WSL

Quick Start

<?php
$libsql = new LibSQL("file:example.db

…

View on GitHub

Seeking Support for Something Useful

Imam Ali Mustofa — Thu, 23 Jan 2025 21:32:45 +0000

Hello Punk, I am back!

After gaining significant attention and a glimmer of hope, the clouds slowly began to roll in.

The Thought

As a Full-time Open Source contributor, this is not just a hobby. What I do is a passion that I continue to learn and grow in every day. Although I am not an expert and do not know everything, I have mastered the skills I possess. I choose not to be a 'Swiss Army knife' but instead to keep learning, sharpening myself, and dreaming of becoming a "Samurai".

Indeed, sometimes my Sufistic side fortifies (not hinders) my mind from being consumed by the pursuit of wealth, because I believe that God is neither foolish nor neglectful toward His creations. That is why I always strive to do things not solely based on 'money,' but rather on personal fulfillment, knowing that what I have done can be useful and beneficial to others.

For 10 years, I have been immersed in the world of programming, and for the past 6 years, I have lived with my small family, including a beautiful daughter who has become the energy and inspiration for my freestyle approach to everything. They (my wife and daughter) are the best and strongest people I have in my life.

Choosing to be a Full-time Open Source contributor in Indonesia is considered a 'CRAZY' decision. Unlike in other countries, where knowledge and creative work are valued appropriately, I am constrained by my own Sufistic mindset. I cannot resist the magic of one simple word that can come from someone's mouth: 'Thank you.' This often creates ambiguity when it clashes with financial realities. Yes, this is the irony I face.

But once again, it all comes back to God, the All-Knowing and the All-Providing.

Future Idea

This year, I am going to create something big, and it will undoubtedly require a lot of time, energy, and thought. Since this idea is still being developed and will later be revealed to the public, you can try to guess for now what it might be. As a clue, you can check out my GitHub profile. From there, you’ll get an idea of what I’m likely working on—everything is interconnected between what’s on my GitHub and the news surrounding it.

Support

If you appreciate someone 'crazy' like me, who supports their family through the passion I have, you can support what I do on GitHub. It would mean the world to me, as there are no words to fully express my gratitude and appreciation for those who use the tools I’ve created over the years.

See you...

Turso libSQL Installer

Imam Ali Mustofa — Sat, 22 Jun 2024 20:10:03 +0000

Hello Punk! Yes I am, in this journal I want to share with you how to install libSQL in your PHP Environment without worry to configure php.ini file in your current PHP Version.

Install the libSQL extension for PHP it's like install a composer package:

composer require vendor/package

to install libSQL extension for PHP

turso-php-installer install

Anyway... I want you to know how the punk'in single file installer script work and setup it for you.

`help` command

You already see in the image above. That's the help command does.

`install` command

The install command will do some necessary checks before installing the libSQL Extension for PHP, what a questions will ask for? (checking in the background)

Are You Using Windows?

Even though Turso Client PHP has an extension built for Windows MSVC 2022. However, the installation process using this installer script will not work for Windows. WSL will work or you can use Turso Docker PHP!

If you're using Windows then you will get this message:

> turso-php-installer install # In Windows
Sorry, Turso PHP Installer is only support for Linux and MacOS.

You are using Windows, you can try our alternative using Dev Containers
visit: https://github.com/darkterminal/turso-docker-php

Thank you!

Are You Using Laravel Herd?

Dang yeah... the installer is not support yet for Laravel Herd. But I will support soon, and you can follow up this discussion on Herd Community GitHub Disccussion.

$ turso-php-installer install
You are using Laravel Herd
Sorry, Laravel Herd is not supported yet.
You can try our alternative using Dev Containers
visit: https://github.com/darkterminal/turso-docker-php

Thank you!

Is Already Installed

Sometimes I forgot when it's already installed.

$ turso-php-installer install
Turso Client PHP is already installed and configured!

Which PHP Version?

Turso Client PHP / libSQL Extension for PHP need minimal PHP 8.0 and later. You see it at Turso Client PHP - Release page

If you have PHP below the minimum requirement, then it will failed

$ turso-php-installer install
Oops! Your PHP version environment does not meet the requirements.
Need a minimal PHP 8.0 installed on your environment.

Check php.ini

The installer script need to lookup

$ turso-php-installer install
You don't have PHP install globaly in your environment
Turso Client PHP lookup php.ini file and it's not found

Check The Functions Requiered

The installer script also need a shell_exec and curl function

$ turso-php-installer install
It looks like the 'shell_exec' and 'curl_version' functions are disabled in your PHP environment. These functions are essential for this script to work properly.
To enable them, follow these steps:
1. Open your 'php.ini' file. You can find the location of your 'php.ini' file by running the command 'php --ini' in your terminal or command prompt.
2. Search for 'disable_functions' directive. It might look something like this:
disable_functions = shell_exec, curl_version
3. Remove 'shell_exec' and 'curl_version' from this list. It should look like:
disable_functions =
4. Save the 'php.ini' file.
5. Restart your web server for the changes to take effect. If you are using Apache, you can restart it with:
sudo service apache2 restart
or for Nginx:
sudo service nginx restart
If you are using a web hosting service, you might need to contact your hosting provider to enable these functions for you.
For more information on 'shell_exec', visit: https://www.php.net/manual/en/function.shell-exec.php
For more information on 'curl_version', visit: https://www.php.net/manual/en/function.curl-version.php
Thank you!

Asking Permission

The installer need to run with sudo role, because the installer will need to write php.ini file in your environment.

$ turso-php-installer install
Turso need to install the client extension in your PHP environment.
This script will ask your sudo password to modify your php.ini file:
Are you ok? [y/N]:

Download and Extract

After all requirements is meet, then installer will download and extract the libSQL Extension for PHP based on Current PHP version that used in your environment and store it at $HOME/.turso-client-php

The extension is required before you used Turso Driver Laravel and Turso Doctrine DBAL

DEV Community: Imam Ali Mustofa

AI Can Write the Code. So What Are You Actually Good At?

The uncomfortable part about AI-assisted development

AI is very good at generating code

The code is not the software

Fundamentals give you a mental debugger

Learn algorithms even if AI can write them

Learn databases before letting AI design your database

Learn networking

Learn your operating system

AI makes shallow knowledge more dangerous

The new skill isn't "prompt engineering"

The fundamentals become your filter

Don't become a code typist

Learn the boring stuff

The paradox of AI

Go beyond the code

I Build libSQL Server Web GUI - MylibSQLAdmin

What’s the Big Deal?

Why did I build MylibSQLAdmin?

darkterminal / mylibsqladmin

MylibSQLAdmin - A Modern libSQL Database Management Platform

What Does MylibSQLAdmin Offer?

From Fun to Frustration: A Lone Wolf in the Open Source World

A Day after Having Fun

Back To Open Source Work

What I've Done Before?

I created Whatsback Web with simple features and made it free and open source. So, what did I get in return? What I got was the realization of how and who truly appreciates the hard work behind a creation.

Whatsback Web: Automate WhatsApp with Power & Responsibility

It's Free and Open Source!

Whatsback Web: Automate WhatsApp with Power & Responsibility

Whatsback Web: Automate WhatsApp with Power & Responsibility

Why I Built Whatsback Web?

Why I Built Whatsback Web—And Why It’s Different From Other Tools

Who Likes Spam?!

Using WhatsApp Web

Getting Started

Docker (The Easy Way)

Docker CLI

Docker Compose

Source Installation

🔐 The Elephant in the Room: Security & Risks

☕ Support the Madness

🚨 Final Warning

Did you know about this?

Why I Built Whatsback Web—And Why It’s Different From Other Tools

Why I Built Whatsback Web—And Why It’s Different From Other Tools

The Breaking Point: “There Has to Be a Better Way”

Building Whatsback Web: A Tool for Myself (and You)

How It Stacks Up Against Other Tools

Why I Open-Sourced It (And Why That Matters)

Your Turn: Automate Without Limits

Support the Project

From Express to Laravel: My Journey of Rewriting a 5-Year-Old REST API (and Surviving the Chaos)

Starting with the Hard Things First

The Real Challenge: Controllers and Models

The Fun Part: Backup Script Magic

Lessons Learned (So Far)

What’s Next?

Lil Story about libSQL Extension in PHP

tursodatabase / turso-client-php

Turso + PHP - libSQL Extension for PHP (Community SDK)

Turso Client PHP

Overview

Supported Versions

Quick Start

Seeking Support for Something Useful

The Thought

Future Idea

Support

Turso libSQL Installer

help command

install command

`help` command

`install` command