Forem: karim tamani

StackRender V1.1.0 is out: Generate Database Migrations from ER Diagram Changes

karim tamani — Thu, 12 Feb 2026 12:54:29 +0000

Hey engineers

Schema evolution is still one of the most painful parts of backend/database development.

I tried multiple tools and workflows (ORM auto-migrations, schema diff tools, etc.), but most of them either add complexity, or hit limitations where you eventually end up writing migrations manually anyway , especially when you care about safe production changes.

So I started building a tool around a simple idea:

Design your database as an ER diagram, track diagram changes over time, and automatically generate production-ready migrations from the diff.

I like to call this approach visual-first database migrations.

1 . How it works

You start with an empty diagram (or import an existing database).
StackRender generates the base migration for you, deploy it and you're done.
Later, whenever you want to update your database, you go back to the diagram and edit it (add tables, edit columns, rename fields, add FK constraints, etc).
StackRender automatically generates a new migration containing only the schema changes you made. Deploy it and keep moving.

2 . Migrations include UP + DOWN scripts

Each generated migration contains two scripts:

UP → applies the changes and moves your database forward
DOWN → rolls back your database to the previous version

Migration up script :

Migration rollback script :

3 . Visual-first vs Code-first database migrations

Most code-first migration tools (like Node.js ORMs such as Prisma, Sequelize, Drizzle, etc.) infer schema changes from code.

That approach works well up to a point, but it can struggle with more complex schema changes. For example:

❌ Some tools may not reliably detect column renames (often turning them into drop + recreate)
❌ Some struggle with Postgres-specific operations like ENUM modifications, etc.

StackRender’s visual-first approach uses a state-diff engine to detect schema changes accurately at the moment you make them in the diagram, and generates the correct migration steps.

4 . What can it handle?

✅ Table changes

Create / drop
Rename (proper rename not drop + recreate)

✅ Column changes

Create / drop
Data type changes
Alter: nullability, uniqueness, PK constraints, length, scale, precision, charset, collation, etc.
Rename (proper rename not drop + recreate)

✅ Relationship changes

Create / drop
FK action changes (ON DELETE / ON UPDATE)
Renaming

✅ Index changes

Create / drop
Rename (when supported by the database)
Add/remove indexed columns

✅ Postgres types (ENUMs)

Create / drop
Rename
Add/remove enum values

If you’re working with Postgres or MySQL, I’d love for you to try it out.
And if you have any feedback , I’m all ears 🙏

Try it free online:
stackrender.io

GitHub:
github.com/stackrender/stackrender

Schema change complete guide for developers :
Guide

Much love ❤️ , Thank you!

Prisma + StackRender: Design Your Database and Start Building Your Backend

karim tamani — Sat, 03 Jan 2026 19:38:05 +0000

Designing a database schema is often one of the slowest parts of starting a new backend project. You either spend time writing SQL by hand or carefully crafting Prisma models before you can even write your first endpoint.

In this article, I’ll show you a faster workflow using Prisma and StackRender that lets you go from an empty project to a working backend in minutes.

We’ll:

Design a PostgreSQL database visually using StackRender
Deploy the database instantly
Pull the schema into Prisma automatically
Start building and testing backend endpoints

Prerequisites

Before we start, make sure you have:

Node.js installed
A PostgreSQL database (local or remote)
Prisma installed and configured in your Node.js project

If you’re new to Prisma, follow the official setup guide before continuing.

Prisma 7 Install guide

Starting With an Empty Project

We begin with a fresh Node.js project where Prisma is already set up.

If you open your schema.prisma file, you’ll notice that it’s completely empty — no models, no relations, nothing defined yet.

At the same time, the connected PostgreSQL database is also empty. There are no tables or constraints created.

This is the perfect starting point.

generator client {
  provider = "prisma-client-js"
  output   = "../src/generated/prisma"
}

datasource db {
  provider = "postgresql"
}

Designing the Database with StackRender

Instead of manually designing the schema, we’ll use StackRender, a free and open-source database schema generator.

Inside StackRender:

Create a new database
Name it ecommerce_db
Choose PostgreSQL as the database type

You’ll start with an empty diagram. From here, you can either design the schema manually or import an existing database.

For this example, we’ll let the AI handle the initial design.

Generating an Ecommerce Schema Using AI

Using StackRender’s AI prompt feature, enter:

Design a multi-vendor ecommerce database

Within seconds, StackRender generates a complete database diagram, including tables, fields, and relationships.

Everything is fully editable — you can rename tables, adjust columns, and fine-tune relationships before moving forward.

Exporting and Deploying the Database

Once the schema looks good:

Open the Code section in StackRender
Export the generated SQL script

Take this SQL script and run it against your PostgreSQL database (for example, using pgAdmin).

After execution, all tables, constraints, and relationships are created automatically.

At this point, your database is fully deployed without writing SQL by hand.

Pulling the Database into Prisma

Now that the database is live, we can sync it back into Prisma.

Run:

npx prisma db pull

Prisma will introspect the database and automatically generate your schema.prisma file based on the existing tables and relations.

This gives you fully defined Prisma models instantly.

generator client {
  provider = "prisma-client-js"
  output   = "../src/generated/prisma"
}

datasource db {
  provider = "postgresql"
}

model cart_items {
  id         Int       @id @default(autoincrement())
  cart_id    Int
  product_id Int
  quantity   Int
  added_at   DateTime? @default(now()) @db.Timestamptz(6)
  carts      carts     @relation(fields: [cart_id], references: [id], onDelete: Cascade, onUpdate: NoAction)
  products   products  @relation(fields: [product_id], references: [id], onDelete: NoAction, onUpdate: NoAction)
}

model carts {
  id         Int          @id @default(autoincrement())
  user_id    Int          @unique
  created_at DateTime?    @default(now()) @db.Timestamptz(6)
  updated_at DateTime?    @default(now()) @db.Timestamptz(6)
  cart_items cart_items[]
  users      users        @relation(fields: [user_id], references: [id], onDelete: NoAction, onUpdate: NoAction)
}

model categories {
  id          Int        @id @default(autoincrement())
  name        String     @unique
  description String?
  products    products[]
}

model order_items {
  id             Int      @id @default(autoincrement())
  order_id       Int
  product_id     Int
  vendor_id      Int
  quantity       Int
  price_per_item Decimal  @db.Decimal(10, 2)
  subtotal       Decimal  @db.Decimal(10, 2)
  orders         orders   @relation(fields: [order_id], references: [id], onDelete: Cascade, onUpdate: NoAction)
  products       products @relation(fields: [product_id], references: [id], onDelete: NoAction, onUpdate: NoAction)
  vendors        vendors  @relation(fields: [vendor_id], references: [id], onDelete: NoAction, onUpdate: NoAction)
}

model orders {
  id               Int                      @id @default(autoincrement())
  user_id          Int
  order_date       DateTime?                @default(now()) @db.Timestamptz(6)
  total_amount     Decimal                  @db.Decimal(10, 2)
  currency         orders_currency_enum
  order_status     orders_order_status_enum @default(pending)
  shipping_address String?
  billing_address  String?
  created_at       DateTime?                @default(now()) @db.Timestamptz(6)
  updated_at       DateTime?                @default(now()) @db.Timestamptz(6)
  order_items      order_items[]
  users            users                    @relation(fields: [user_id], references: [id], onDelete: NoAction, onUpdate: NoAction)
  payments         payments?
  shipments        shipments?
}

model payments {
  id             Int                          @id @default(autoincrement())
  order_id       Int                          @unique
  payment_date   DateTime?                    @db.Timestamptz(6)
  amount         Decimal                      @db.Decimal(10, 2)
  payment_method String?
  transaction_id String?                      @unique
  payment_status payments_payment_status_enum @default(unpaid)
  created_at     DateTime?                    @default(now()) @db.Timestamptz(6)
  updated_at     DateTime?                    @default(now()) @db.Timestamptz(6)
  orders         orders                       @relation(fields: [order_id], references: [id], onDelete: Cascade, onUpdate: NoAction)
}

model product_images {
  id            Int      @id @default(autoincrement())
  product_id    Int
  image_url     String
  alt_text      String?
  display_order Int?
  products      products @relation(fields: [product_id], references: [id], onDelete: Cascade, onUpdate: NoAction)
}

model products {
  id             Int              @id @default(autoincrement())
  vendor_id      Int
  category_id    Int?
  name           String
  description    String?
  price          Decimal          @db.Decimal(10, 2)
  stock_quantity Int
  sku            String?          @unique
  created_at     DateTime?        @default(now()) @db.Timestamptz(6)
  updated_at     DateTime?        @default(now()) @db.Timestamptz(6)
  cart_items     cart_items[]
  order_items    order_items[]
  product_images product_images[]
  categories     categories?      @relation(fields: [category_id], references: [id], onDelete: NoAction, onUpdate: NoAction)
  vendors        vendors          @relation(fields: [vendor_id], references: [id], onDelete: NoAction, onUpdate: NoAction)
  reviews        reviews[]
}

model reviews {
  id          Int       @id @default(autoincrement())
  product_id  Int
  user_id     Int
  rating      Int
  comment     String?
  review_date DateTime? @default(now()) @db.Timestamptz(6)
  products    products  @relation(fields: [product_id], references: [id], onDelete: Cascade, onUpdate: NoAction)
  users       users     @relation(fields: [user_id], references: [id], onDelete: NoAction, onUpdate: NoAction)
}

model shipments {
  id                 Int                               @id @default(autoincrement())
  order_id           Int                               @unique
  shipment_date      DateTime?                         @db.Timestamptz(6)
  tracking_number    String?                           @unique
  carrier            String?
  fulfillment_status shipments_fulfillment_status_enum @default(not_fulfilled)
  created_at         DateTime?                         @default(now()) @db.Timestamptz(6)
  updated_at         DateTime?                         @default(now()) @db.Timestamptz(6)
  orders             orders                            @relation(fields: [order_id], references: [id], onDelete: Cascade, onUpdate: NoAction)
}

model users {
  id               Int       @id @default(autoincrement())
  username         String    @unique
  email            String    @unique
  password_hash    String
  first_name       String?
  last_name        String?
  shipping_address String?
  billing_address  String?
  created_at       DateTime? @default(now()) @db.Timestamptz(6)
  updated_at       DateTime? @default(now()) @db.Timestamptz(6)
  carts            carts?
  orders           orders[]
  reviews          reviews[]
}

model vendor_payouts {
  id             Int       @id @default(autoincrement())
  vendor_id      Int
  payout_date    DateTime? @default(now()) @db.Timestamptz(6)
  amount         Decimal   @db.Decimal(10, 2)
  transaction_id String?   @unique
  vendors        vendors   @relation(fields: [vendor_id], references: [id], onDelete: NoAction, onUpdate: NoAction)
}

model vendors {
  id             Int              @id @default(autoincrement())
  name           String
  email          String           @unique
  phone_number   String?
  address        String?
  created_at     DateTime?        @default(now()) @db.Timestamptz(6)
  updated_at     DateTime?        @default(now()) @db.Timestamptz(6)
  order_items    order_items[]
  products       products[]
  vendor_payouts vendor_payouts[]
}

enum orders_currency_enum {
  USD
  EUR
  GBP
}

enum orders_order_status_enum {
  pending
  processing
  shipped
  delivered
  cancelled
}

enum payments_payment_status_enum {
  unpaid
  paid
  refunded
}

enum shipments_fulfillment_status_enum {
  not_fulfilled
  fulfilled
  partially_fulfilled
}

Testing Everything with a Real Endpoint

To verify that everything works end to end, we can create a simple backend feature.

In this example, we implement a POST /product endpoint using:

Express for the server
Zod for request validation
Prisma for database access

router.post("/product", async (request: Request, response: Response) => {
    try {
        const result = createProductSchema.safeParse(request.body)
        if ( ! result.success) {
            response.status(400).json(result) ; return ; 
        }

        const { data } = result ; 

        const product = await prisma.products.create({
            data : {
                ...data , 
                product_images  : {
                    create : data.product_images.map(( productImage : CreateProductImageInput) => productImage) 
                }

            }  , 
            include : { 
                vendors : true , 
                categories : true , 
                product_images : true , 
            } 
        })


        response.status(200).json({ success : true , data : product }) ; 
    } catch (error) {
        console.log (error) ; 
        response.status(500).json({ error, success: false })
    }
})

The endpoint:

Receives product data from the client
Validates the input using Zod
Inserts the product and its images into the database using Prisma
Returns the created product with its category, vendor, and images

Before sending any request, the product table is empty.

After sending a test request (for example using Postman), a new product record appears in the database, along with its related images.

This confirms that the schema, Prisma models, and backend logic are all working together correctly.

Why This Workflow Works So Well

This approach allows you to:

Design databases visually
Avoid writing SQL manually
Skip writing Prisma models by hand
Move from schema design to backend code much faster

It’s especially useful when starting new projects or prototyping ideas quickly.

Conclusion

By combining StackRender and Prisma, you get a smooth workflow from database design to production-ready backend code.

If you’re building backends with Prisma and PostgreSQL, this setup can save you a lot of time and reduce friction during the early stages of development.

Feel free to check the resources linked below to get started with StackRender and Prisma.

StackRender :
Website
Github

Generate Database Schemas with AI: How StackRender Builds Your DB in Seconds

karim tamani — Wed, 03 Dec 2025 20:37:01 +0000

In an era where data is at the heart of every digital interaction, the tools we use to manage databases are more critical than ever. StackRender emerges as a robust solution for engineers seeking to design, optimize, and deploy databases with precision and speed. This article explores the seamless journey from blueprint to deployment using StackRender, a cutting-edge database schema diagram generator.

Key Features of StackRender
StackRender is trusted by over 280 engineers, and for good reason. It offers an intuitive platform that leverages AI to facilitate the entire lifecycle of database management, from initial design to deployment.

AI-Powered Database Design
At the core of StackRender’s offering is its AI-powered assistant, which simplifies the process of generating database schemas. This feature allows users to transition from specifications to a fully functional database by automatically creating tailored diagrams. The AI assistant helps in configuring schema, indices, and even managing soft deletes, enabling users to handle complex database requirements effortlessly.

Interactive Diagram UI
StackRender’s interactive diagram UI provides a visual approach to database management. Users can visualize and organize their databases with clarity, making it easier to understand and modify complex relationships between tables. This feature is particularly beneficial for frontend engineers or those less familiar with backend processes, as it bridges the gap between technical complexity and user-friendly design.

Flexible SQL Import & Export
Flexibility is at the heart of StackRender’s SQL import and export capabilities. The platform supports multiple SQL dialects, including Postgres, MySQL, and SQLite, among others. This flexibility ensures that users can easily integrate StackRender into their existing workflows, regardless of the database systems they use.

Precision Table Control
Precision is key when managing databases, and StackRender delivers with its table control features. Users can edit table columns, attributes, and indices, ensuring that every detail of their database is tailored to their specific needs. This level of control allows for optimal database performance and scalability.

Real Use-Case Scenarios
StackRender shines in real-world applications, providing seamless database management solutions across various industries. Consider a rapidly growing e-commerce platform needing to scale its database to accommodate increasing user data and transactions. Using StackRender, the engineering team can swiftly design a robust database schema, ensuring that critical tables like orders, products, and users are optimized for performance. With the interactive diagram UI, the team can visualize data relationships, facilitating a clearer understanding of the database structure and enhancing collaboration among team members.

Moreover, StackRender’s AI-powered assistant can suggest optimizations and automatically generate documentation, streamlining the onboarding process for new team members and reducing the time needed for database management tasks.

How It Works
The StackRender workflow is designed to be intuitive and efficient, following a three-step process that transforms initial ideas into production-ready databases.

From Idea to Blueprint
The journey begins with the creation of a database blueprint. Users can start by using the AI assistant to generate a database diagram based on initial specifications, or they can import existing databases for optimization. This flexibility allows users to approach database design in a way that best suits their project’s requirements.

Shape It Your Way
Once the blueprint is in place, users have full control over the database model. StackRender allows for extensive customization, enabling users to add tables, tweak columns, set indexes, and refine every detail. This step ensures that the database not only meets current needs but is also prepared for future scalability and performance enhancements.

Optimize & Export
The final step in the StackRender workflow involves optimization and export. The platform fine-tunes the database design for optimal performance, allowing users to export production-ready DDL in any SQL dialect. This feature ensures that the database is ready to be deployed seamlessly into the production environment.

Conclusion

StackRender provides a powerful, user-friendly platform for database design and deployment, catering to engineers across various expertise levels. Its AI-powered features, interactive UI, and flexible SQL support make it a versatile tool for managing complex database systems. Whether you’re a frontend engineer like Anton Boltnev, who praised StackRender for its simplicity and visual clarity, or a seasoned backend developer, StackRender offers a streamlined approach to database management.

For those looking to enhance their database design capabilities, StackRender presents a compelling option that combines innovation with practicality, ensuring that your database journey is as seamless as possible.

🚀Try StackRender Online or Explore the Open-Source Version

If you want to experience this workflow yourself, you can:

👉 Try StackRender Online
👉 Clone on GitHub .

Both options let you start designing smarter, faster, and more confidently.

Backend devs , what do you use for database migrations, and what do you wish existed?

karim tamani — Tue, 18 Nov 2025 13:26:26 +0000

Hey folks,

I’ve been experimenting with some new ideas around generating and managing database migrations (mainly Postgres+ MySQL). Before I go deeper, I’m curious how others think about this stuff in real projects.

Which tools or ORMs are you using for migrations today? (Prisma, Sequelize, TypeORM, Knex, Flyway, Liquibase, raw SQL, etc.)

I noticed something interesting:

Tools like Flyway/Liquibase don’t generate migrations , they only execute them.
ORMs do generate migrations, but they have quirks. For example:
1. - Sequelize sometimes fails to alter certain Postgres types.
2. - Prisma drops+recreates a column when you just rename it.
3. - Some tools can’t detect complex schema differences at all.

So I’m wondering:

If you could redesign database migrations from scratch
What would you want done differently ?
What’s missing ? What’s painful ? What’s unreliable?

Would love to hear the raw opinions from people who deal with this stuff every day.

Discussion: How do you feel about giving your database credentials to cloud-hosted dev tools?

karim tamani — Sun, 02 Nov 2025 16:03:54 +0000

Question for DB folks:

Curious to hear what people think about this.

Many modern database tools (like schema editors, query explorers, or version control tools) ask for your database connection string so they can connect remotely and perform operations.

Even when they claim to encrypt credentials or use temporary sessions, I’ve always wondered how comfortable developers really are with that.

So, what’s your take?

Would you ever give your production or staging DB credentials to a cloud-hosted tool?
What level of transparency or control would make you trust it?

Not trying to start a debate , just genuinely curious where most developers stand on the security vs. convenience trade-off here.

🚀 This is By Far the Best Database Sync Technology

karim tamani — Thu, 17 Jul 2025 11:50:34 +0000

Keeping your frontend in sync with your backend especially in real-time and offline scenarios has always been a nightmare. Between polling, WebSockets, conflict resolution, and unreliable network connections, most developers either roll out overly complex systems or compromise on user experience.

But recently, I came across something that changes the game:

💡 PowerSync a blazing fast, offline-first sync engine built on Postgres and WebSocket.

It’s designed to help developers build modern apps with real-time sync, offline support, and zero polling without sacrificing simplicity or performance.

What is PowerSync?

PowerSync lets you build apps where local and remote data stay in perfect sync automatically. It works by syncing changes between a Postgres backend and a client-side database (like SQLite) using **WebSocket **and delta-based sync logic.

Highlights:

Offline-first out of the box
Syncs data in real-time (both ways)
Uses Postgres + WebSocket under the hood
Works seamlessly with mobile, web, and desktop
Native SDKs for React-Native, React, and more

You get a local-first experience without writing a custom sync engine from scratch.

Getting Started

PowerSync supports a growing list of platforms. Here’s where to get started:

Flutter – for mobile apps and Flutter Web
React Native – supports mobile and React Native Web
JavaScript Web – including integrations for React and Vue
Kotlin Multiplatform
Swift
Node.js (alpha)
.NET (alpha)

Explore Live Demos & Example Projects

Want to see PowerSync in action? The team has put together a collection of live demos and open-source example projects to help you understand how real-time sync and offline-first capabilities work in practice.

👉 View all demos & example projects →

These include:

To-Do List Apps with real-time updates and offline syncing
Chat Apps demonstrating message sync and conflict-free behavior
Mobile apps using Flutter, React Native, and more

Each demo is tied to an open-source repo you can fork, run, or study — perfect for learning or integrating into your own product.

Whether you're building a mobile CRM, logistics tracker, or collaborative SaaS tool, these examples give you a real feel for how PowerSync works in production.

Final Thoughts

If you’re building apps that need to work offline, update in real-time, and stay in sync without hacks, PowerSync is the most promising solution I’ve seen in a long time.

Whether you’re working on a SaaS platform, a mobile CRM, a logistics tracker, or a collaborative app — this tool is worth exploring.

Give it a try, and let me know what you think!
Got questions or want help getting started? Drop a comment below .

🚀 Auto-Generate Sequelize Models and Migrations with StackRender

karim tamani — Mon, 14 Apr 2025 17:07:19 +0000

Managing Sequelize models and migrations manually can quickly become tedious, especially when your application starts growing in complexity. Wouldn’t it be great if you could visually define your database schema and instantly generate the corresponding Sequelize code? That’s exactly what StackRender brings to the table.

In this article, I’ll walk you through how to use StackRender, a visual code generation tool, to auto-generate *Sequelize models and migrations * for your Node.js projects.

🔧 What is StackRender?
StackRender is a developer tool designed to speed up backend and frontend development by allowing you to:

Visually design your database schema.
Auto-generate models, migrations, and boilerplate code.
Choose your stack (e.g., Sequelize, Prisma, Mongoose).
Export clean, production-ready code.

No more repetitive typing, no more worrying about typos in your models—just focus on building your app.

🛠️ How to Use StackRender for Sequelize
Step 1: Design Your Database Schema Visually
Once you're logged into StackRender:

Create a new project.

Use the visual schema builder to create tables (models), define fields, set their types, and create associations (One-to-Many, Many-to-Many, etc.).

Assign field constraints such as allowNull, unique, defaultValue, or primaryKey.

For example:

Table: User
Fields: id, name, email, password

Table: Post
Fields: id, title, content, userId

Association: User hasMany Post

Step 2: Select Sequelize as Your Stack
When you’re done designing your schema:

Go to the Export section.
Choose Sequelize as the backend technology.
Optionally, select whether you want only models, migrations, or both.

Step 3: Download and Use the Code
Click the "Generate & Download" button. You’ll get a zip file containing:

/models folder with fully defined Sequelize models.
/migrations folder with timestamped migration files.

A sample database configuration file (config/config.js).
Optional seeders if enabled.
Just drop these into your existing Sequelize project or use them to start a new one!

bash
Copier
Modifier
npm install sequelize sequelize-cli pg # or mysql2/sqlite3 npx sequelize-cli db:migrate
Boom 💥 — your tables are now live in your database!

🎁 What Makes StackRender Special?
Fast Iteration: Instantly regenerate models/migrations when your schema changes.

Visual Modeling: No need to remember syntax. Just drag, drop, and define.
Associations Made Easy: Automatically sets up foreign keys and relationship logic.

Customizable Output: Choose what you want to generate.

🤔 Why Use StackRender?
Here’s why developers are loving StackRender:

Saves hours of setup time.
Keeps code consistent across projects.
Ideal for startups, hackathons, or any project where speed is key.
Great for teams working on shared schema definitions.

🚀 Final Thoughts
StackRender turns your database schema into Sequelize code with just a few clicks. Whether you're a solo dev or part of a team, it can dramatically boost your productivity and reduce boilerplate code.

So the next time you're about to manually define your models and migrations, give StackRender a shot. You might never go back.

🔗 Try StackRender Now .

React Joyride Made My App More Fun — And Kept Users Around Longer

karim tamani — Fri, 11 Apr 2025 14:29:24 +0000

A few weeks ago, I launched a dev tool called Stack Render, aimed at helping developers and indie makers build their MVPs faster and get to market in no time.

In the first couple of weeks, I managed to get a few users. But I quickly noticed a problem : low engagement. Most users were signing up and then leaving the app shortly after .

To fix this, I implemented an interactive product tour using React Joyride. This helped guide users through key features and showcase the actual value Stack Render offers.

My average user engagement time increased significantly.

🚀 Introducing Stack Render: Instantly Generate Express + GraphQL APIs from Your ERD

karim tamani — Sat, 05 Apr 2025 16:04:28 +0000

Hey Devs 👋

A few months ago, I posted on Reddit about a small experiment that grew into something pretty exciting. Like many of you, I was constantly looking for ways to speed up backend development without sacrificing flexibility. So I built a tool that does just that — meet Stack Render.

🛠️ What is Stack Render?
Stack Render is a tool that generates a fully functional Express + GraphQL backend directly from your Entity Relationship Diagram (ERD). Instead of spending hours wiring up models, endpoints, and resolvers, you can generate a ready-to-run backend in minutes.

Here's what it generates for you:

✅ Sequelize Models & Migrations

⚙️ GraphQL Inputs, Types, and Endpoints – fully customizable

🔄 GraphQL Resolvers – with built-in data validation and support for file uploads

🔐 Authentication & Authorization – currently in progress

💾 Downloadable Backend – test it locally, tweak it however you want

💡 Why I Built It
Backend work is full of repetitive boilerplate. Creating models, setting up endpoints, writing resolvers — it’s easy to lose days (or weeks) just scaffolding. Stack Render helps eliminate that grind so we can focus on what actually matters: building features that solve real problems.

⚡ The Workflow
Design your ERD in Stack Render

Customize your Inputs , Types & Endpoints

Download a complete Express + GraphQL backend

Customize, test, deploy

That’s it. No magic, just a lot of code generation love behind the scenes.

🧪 Still a Work in Progress
Authentication and authorization layers are still under construction, but the current version already covers a ton of ground — especially if you're building CRUD-heavy applications.

👨‍💻 Who’s it for?
Developers building MVPs

Solo devs looking to accelerate development

Startups that want to move fast without skipping best practices

Anyone tired of boilerplate

🔍 What's Next?
OAuth integration

More complex relationships and computed fields

Deployment templates

REST API generation (maybe?)

🎯 Try It Out!
I’d love for you to give it a try, break it, and tell me what you think. This tool is made for devs like you — feedback is gold 🏆.

Feel free to drop a comment or DM me on Twitter or GitHub — I’m always down to improve this with the community.

Let’s spend less time writing boilerplate and more time building amazing things.

Happy coding,

Critical security flaw uncovered in Next.js framework

karim tamani — Tue, 01 Apr 2025 07:53:08 +0000

A significant security vulnerability has been identified in the widely used Next.js framework, potentially affecting millions of websites and applications.

Security researchers Rachid Allam (zhero) and Yasser Allam (inzo_) collaborated to uncover the flaw within the framework’s middleware functionality.

Next.js, a React-based framework with over 130,000 GitHub stars and nearly 10 million weekly downloads, is favored by developers for its rich feature set. However, its extensive capabilities also create a broad attack surface, attracting security scrutiny.

https://www.developer-tech.com/news/critical-security-flaw-uncovered-next-js-framework/

Express v5.1.0 is latest!

karim tamani — Mon, 31 Mar 2025 16:16:18 +0000

Express released 5.0.0 about 6 months ago but are finally going latest with the new major version.

https://expressjs.com/2025/03/31/v5-1-latest-release.html

Top 5 Node ORMs to Learn in 2025

karim tamani — Fri, 28 Mar 2025 23:15:57 +0000

If you're looking for the best Node.js ORMs to learn in 2025, here are the top five, ranked based on their popularity, feature set, and ecosystem support:

1. Prisma

Why Learn? Modern, type-safe, and developer-friendly ORM with excellent TypeScript support.
Key Features:
- Auto-generated, type-safe queries
- Supports PostgreSQL, MySQL, SQLite, MongoDB, and CockroachDB
- Built-in migrations and database schema management
- Great for Next.js and serverless applications
Best For: TypeScript developers, modern full-stack apps, and projects needing strong database abstraction.

2. Sequelize

Why Learn? The most established ORM for SQL databases in Node.js.
Key Features:
- Supports PostgreSQL, MySQL, MariaDB, SQLite, and MSSQL
- Promise-based API with flexible query options
- Raw SQL support and transaction handling
- Active community and ecosystem
Best For: Developers needing a mature and widely used ORM with relational databases.

3. TypeORM

Why Learn? Fully-featured ORM with deep TypeScript integration.
Key Features:
- Supports multiple database systems (SQL and NoSQL)
- Decorator-based syntax (great for NestJS users)
- Active record and data mapper patterns
- CLI for migrations and schema management
Best For: TypeScript developers, NestJS projects, and enterprise-level applications.

4. Drizzle ORM

Why Learn? A lightweight, SQL-first ORM focused on performance.
Key Features:
- TypeScript-first with full type safety
- SQL-like API without unnecessary abstractions
- Works with PostgreSQL, MySQL, SQLite, and Planetscale
- Fast migrations and lightweight footprint
Best For: Performance-focused applications and developers who prefer raw SQL flexibility with TypeScript safety.

5. Objection.js

Why Learn? A relational ORM built on top of Knex.js with strong SQL query capabilities.
Key Features:
- Supports PostgreSQL, MySQL, SQLite, and MSSQL
- Hybrid approach (ORM + Query Builder flexibility)
- Excellent relation mapping and eager loading
- Works well with Express and Koa
Best For: Developers who need a mix of raw SQL power and ORM convenience.

Which One Should You Learn?

For TypeScript & Modern Development → Prisma, Drizzle ORM
For Traditional Relational Databases → Sequelize, TypeORM
For SQL Query Flexibility → Objection.js